projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Merge pull request #291 from hops/master
[hashcat.git] / src / oclHashcat.c
1 /**
2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
5 *
6 * License.....: MIT
7 */
8
9 #ifdef OSX
10 #include <stdio.h>
11 #endif
12
13 #include <common.h>
14 #include <shared.h>
15 #include <rp_kernel_on_cpu.h>
16 #include <getopt.h>
17
18 const char *PROGNAME = "oclHashcat";
19 const uint VERSION_BIN = 210;
20 const uint RESTORE_MIN = 210;
21
22 double TARGET_MS_PROFILE[3] = { 8, 16, 96 };
23
24 #define INCR_RULES 10000
25 #define INCR_SALTS 100000
26 #define INCR_MASKS 1000
27 #define INCR_POT 1000
28
29 #define USAGE 0
30 #define VERSION 0
31 #define QUIET 0
32 #define MARKOV_THRESHOLD 0
33 #define MARKOV_DISABLE 0
34 #define MARKOV_CLASSIC 0
35 #define BENCHMARK 0
36 #define BENCHMARK_REPEATS 2
37 #define RESTORE 0
38 #define RESTORE_TIMER 60
39 #define RESTORE_DISABLE 0
40 #define STATUS 0
41 #define STATUS_TIMER 10
42 #define STATUS_AUTOMAT 0
43 #define LOOPBACK 0
44 #define WEAK_HASH_THRESHOLD 100
45 #define SHOW 0
46 #define LEFT 0
47 #define USERNAME 0
48 #define REMOVE 0
49 #define REMOVE_TIMER 60
50 #define SKIP 0
51 #define LIMIT 0
52 #define KEYSPACE 0
53 #define POTFILE_DISABLE 0
54 #define DEBUG_MODE 0
55 #define RP_GEN 0
56 #define RP_GEN_FUNC_MIN 1
57 #define RP_GEN_FUNC_MAX 4
58 #define RP_GEN_SEED 0
59 #define RULE_BUF_L ":"
60 #define RULE_BUF_R ":"
61 #define FORCE 0
62 #define RUNTIME 0
63 #define HEX_CHARSET 0
64 #define HEX_SALT 0
65 #define HEX_WORDLIST 0
66 #define OUTFILE_FORMAT 3
67 #define OUTFILE_AUTOHEX 1
68 #define OUTFILE_CHECK_TIMER 5
69 #define ATTACK_MODE 0
70 #define HASH_MODE 0
71 #define SEGMENT_SIZE 32
72 #define INCREMENT 0
73 #define INCREMENT_MIN 1
74 #define INCREMENT_MAX PW_MAX
75 #define SEPARATOR ':'
76 #define BITMAP_MIN 16
77 #define BITMAP_MAX 24
78 #define GPU_TEMP_DISABLE 0
79 #define GPU_TEMP_ABORT 90
80 #define GPU_TEMP_RETAIN 80
81 #define WORKLOAD_PROFILE 2
82 #define KERNEL_ACCEL 0
83 #define KERNEL_LOOPS 0
84 #define KERNEL_RULES 1024
85 #define KERNEL_COMBS 1024
86 #define KERNEL_BFS 1024
87 #define KERNEL_THREADS 64
88 #define POWERTUNE_ENABLE 0
89 #define LOGFILE_DISABLE 0
90 #define SCRYPT_TMTO 0
91 #define OPENCL_VECTOR_WIDTH 0
92
93 #define WL_MODE_STDIN 1
94 #define WL_MODE_FILE 2
95 #define WL_MODE_MASK 3
96
97 #define HL_MODE_FILE 4
98 #define HL_MODE_ARG 5
99
100 #define HLFMTS_CNT 11
101 #define HLFMT_HASHCAT 0
102 #define HLFMT_PWDUMP 1
103 #define HLFMT_PASSWD 2
104 #define HLFMT_SHADOW 3
105 #define HLFMT_DCC 4
106 #define HLFMT_DCC2 5
107 #define HLFMT_NETNTLM1 7
108 #define HLFMT_NETNTLM2 8
109 #define HLFMT_NSLDAP 9
110 #define HLFMT_NSLDAPS 10
111
112 #define HLFMT_TEXT_HASHCAT "native hashcat"
113 #define HLFMT_TEXT_PWDUMP "pwdump"
114 #define HLFMT_TEXT_PASSWD "passwd"
115 #define HLFMT_TEXT_SHADOW "shadow"
116 #define HLFMT_TEXT_DCC "DCC"
117 #define HLFMT_TEXT_DCC2 "DCC 2"
118 #define HLFMT_TEXT_NETNTLM1 "NetNTLMv1"
119 #define HLFMT_TEXT_NETNTLM2 "NetNTLMv2"
120 #define HLFMT_TEXT_NSLDAP "nsldap"
121 #define HLFMT_TEXT_NSLDAPS "nsldaps"
122
123 #define ATTACK_MODE_STRAIGHT 0
124 #define ATTACK_MODE_COMBI 1
125 #define ATTACK_MODE_TOGGLE 2
126 #define ATTACK_MODE_BF 3
127 #define ATTACK_MODE_PERM 4
128 #define ATTACK_MODE_TABLE 5
129 #define ATTACK_MODE_HYBRID1 6
130 #define ATTACK_MODE_HYBRID2 7
131 #define ATTACK_MODE_NONE 100
132
133 #define ATTACK_KERN_STRAIGHT 0
134 #define ATTACK_KERN_COMBI 1
135 #define ATTACK_KERN_BF 3
136 #define ATTACK_KERN_NONE 100
137
138 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
139 #define ATTACK_EXEC_INSIDE_KERNEL 11
140
141 #define COMBINATOR_MODE_BASE_LEFT 10001
142 #define COMBINATOR_MODE_BASE_RIGHT 10002
143
144 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
145 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
146
147 #define MAX_CUT_TRIES 4
148
149 #define MAX_DICTSTAT 10000
150
151 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 135
152
153 #define global_free(attr) \
154 { \
155 myfree ((void *) data.attr); \
156 \
157 data.attr = NULL; \
158 }
159
160 #define local_free(attr) \
161 { \
162 myfree ((void *) attr); \
163 \
164 attr = NULL; \
165 }
166
167 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
168 {
169 900,
170 0,
171 5100,
172 100,
173 1400,
174 10800,
175 1700,
176 5000,
177 10100,
178 6000,
179 6100,
180 6900,
181 11700,
182 11800,
183 400,
184 8900,
185 11900,
186 12000,
187 10900,
188 12100,
189 23,
190 2500,
191 5300,
192 5400,
193 5500,
194 5600,
195 7300,
196 7500,
197 13100,
198 8300,
199 11100,
200 11200,
201 11400,
202 121,
203 2611,
204 2711,
205 2811,
206 8400,
207 11,
208 2612,
209 7900,
210 21,
211 11000,
212 124,
213 10000,
214 3711,
215 7600,
216 12,
217 131,
218 132,
219 1731,
220 200,
221 300,
222 3100,
223 112,
224 12300,
225 8000,
226 141,
227 1441,
228 1600,
229 12600,
230 1421,
231 101,
232 111,
233 1711,
234 3000,
235 1000,
236 1100,
237 2100,
238 12800,
239 1500,
240 12400,
241 500,
242 3200,
243 7400,
244 1800,
245 122,
246 1722,
247 7100,
248 6300,
249 6700,
250 6400,
251 6500,
252 2400,
253 2410,
254 5700,
255 9200,
256 9300,
257 22,
258 501,
259 5800,
260 8100,
261 8500,
262 7200,
263 9900,
264 7700,
265 7800,
266 10300,
267 8600,
268 8700,
269 9100,
270 133,
271 11600,
272 12500,
273 13000,
274 13200,
275 13300,
276 6211,
277 6221,
278 6231,
279 6241,
280 8800,
281 12900,
282 12200,
283 9700,
284 9710,
285 9800,
286 9810,
287 9400,
288 9500,
289 9600,
290 10400,
291 10410,
292 10500,
293 10600,
294 10700,
295 9000,
296 5200,
297 6800,
298 6600,
299 8200,
300 11300,
301 12700,
302 13400,
303 125
304 };
305
306 /**
307 * types
308 */
309
310 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
311
312 /**
313 * globals
314 */
315
316 static unsigned int full01 = 0x01010101;
317 static unsigned int full80 = 0x80808080;
318
319 int SUPPRESS_OUTPUT = 0;
320
321 hc_thread_mutex_t mux_adl;
322 hc_thread_mutex_t mux_counter;
323 hc_thread_mutex_t mux_dispatcher;
324 hc_thread_mutex_t mux_display;
325
326 hc_global_data_t data;
327
328 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
329
330 const char *USAGE_MINI[] =
331 {
332 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
333 "",
334 "Try --help for more help.",
335 NULL
336 };
337
338 const char *USAGE_BIG[] =
339 {
340 "%s, advanced password recovery",
341 "",
342 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
343 "",
344 "=======",
345 "Options",
346 "=======",
347 "",
348 "* General:",
349 "",
350 " -m, --hash-type=NUM Hash-type, see references below",
351 " -a, --attack-mode=NUM Attack-mode, see references below",
352 " -V, --version Print version",
353 " -h, --help Print help",
354 " --quiet Suppress output",
355 "",
356 "* Misc:",
357 "",
358 " --hex-charset Assume charset is given in hex",
359 " --hex-salt Assume salt is given in hex",
360 " --hex-wordlist Assume words in wordlist is given in hex",
361 " --force Ignore warnings",
362 " --status Enable automatic update of the status-screen",
363 " --status-timer=NUM Seconds between status-screen update",
364 " --status-automat Display the status view in a machine readable format",
365 " --loopback Add new plains to induct directory",
366 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
367 "",
368 "* Markov:",
369 "",
370 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
371 " --markov-disable Disables markov-chains, emulates classic brute-force",
372 " --markov-classic Enables classic markov-chains, no per-position enhancement",
373 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
374 "",
375 "* Session:",
376 "",
377 " --runtime=NUM Abort session after NUM seconds of runtime",
378 " --session=STR Define specific session name",
379 " --restore Restore session from --session",
380 " --restore-disable Do not write restore file",
381 "",
382 "* Files:",
383 "",
384 " -o, --outfile=FILE Define outfile for recovered hash",
385 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
386 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
387 " --outfile-check-timer=NUM Seconds between outfile checks",
388 " -p, --separator=CHAR Separator char for hashlists and outfile",
389 " --show Show cracked passwords only",
390 " --left Show un-cracked passwords only",
391 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
392 " --remove Enable remove of hash once it is cracked",
393 " --remove-timer=NUM Update input hash file each NUM seconds",
394 " --potfile-disable Do not write potfile",
395 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
396 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
397 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
398 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
399 " --logfile-disable Disable the logfile",
400 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
401 "",
402 "* Resources:",
403 "",
404 " -b, --benchmark Run benchmark",
405 " --benchmark-repeats=NUM Repeat the kernel on the device NUM times to increase benchmark accuracy",
406 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
407 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
408 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
409 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
410 " --opencl-platforms=STR OpenCL platforms to use, separate with comma",
411 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
412 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
413 " --opencl-vector-width=NUM OpenCL vector-width (either 1, 2, 4, 8 or 16), overrides value from device query",
414 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
415 " -n, --kernel-accel=NUM Workload tuning, increase the outer-loop step size",
416 " -u, --kernel-loops=NUM Workload tuning, increase the inner-loop step size",
417 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
418 #ifdef HAVE_HWMON
419 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
420 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
421 #ifdef HAVE_ADL
422 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
423 #endif
424 #endif
425 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
426 "",
427 "* Distributed:",
428 "",
429 " -s, --skip=NUM Skip number of words",
430 " -l, --limit=NUM Limit number of words",
431 " --keyspace Show keyspace base:mod values and quit",
432 "",
433 "* Rules:",
434 "",
435 " -j, --rule-left=RULE Single rule applied to each word from left dict",
436 " -k, --rule-right=RULE Single rule applied to each word from right dict",
437 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
438 " -g, --generate-rules=NUM Generate NUM random rules",
439 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
440 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
441 " --generate-rules-seed=NUM Force RNG seed to NUM",
442 "",
443 "* Custom charsets:",
444 "",
445 " -1, --custom-charset1=CS User-defined charsets",
446 " -2, --custom-charset2=CS Example:",
447 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
448 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
449 "",
450 "* Increment:",
451 "",
452 " -i, --increment Enable increment mode",
453 " --increment-min=NUM Start incrementing at NUM",
454 " --increment-max=NUM Stop incrementing at NUM",
455 "",
456 "==========",
457 "References",
458 "==========",
459 "",
460 "* Workload Profile:",
461 "",
462 " 1 = Interactive performance profile, kernel execution runtime to 8ms, lower latency desktop, lower speed",
463 " 2 = Default performance profile, kernel execution runtime to 16ms, economic setting",
464 " 3 = Headless performance profile, kernel execution runtime to 96ms, higher latency desktop, higher speed",
465 "",
466 "* OpenCL device-types:",
467 "",
468 " 1 = CPU devices",
469 " 2 = GPU devices",
470 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
471 "",
472 "* Outfile Formats:",
473 "",
474 " 1 = hash[:salt]",
475 " 2 = plain",
476 " 3 = hash[:salt]:plain",
477 " 4 = hex_plain",
478 " 5 = hash[:salt]:hex_plain",
479 " 6 = plain:hex_plain",
480 " 7 = hash[:salt]:plain:hex_plain",
481 " 8 = crackpos",
482 " 9 = hash[:salt]:crackpos",
483 " 10 = plain:crackpos",
484 " 11 = hash[:salt]:plain:crackpos",
485 " 12 = hex_plain:crackpos",
486 " 13 = hash[:salt]:hex_plain:crackpos",
487 " 14 = plain:hex_plain:crackpos",
488 " 15 = hash[:salt]:plain:hex_plain:crackpos",
489 "",
490 "* Debug mode output formats (for hybrid mode only, by using rules):",
491 "",
492 " 1 = save finding rule",
493 " 2 = save original word",
494 " 3 = save original word and finding rule",
495 " 4 = save original word, finding rule and modified plain",
496 "",
497 "* Built-in charsets:",
498 "",
499 " ?l = abcdefghijklmnopqrstuvwxyz",
500 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
501 " ?d = 0123456789",
502 " ?s = !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
503 " ?a = ?l?u?d?s",
504 " ?b = 0x00 - 0xff",
505 "",
506 "* Attack modes:",
507 "",
508 " 0 = Straight",
509 " 1 = Combination",
510 " 3 = Brute-force",
511 " 6 = Hybrid dict + mask",
512 " 7 = Hybrid mask + dict",
513 "",
514 "* Hash types:",
515 "",
516 "[[ Roll-your-own: Raw Hashes ]]",
517 "",
518 " 900 = MD4",
519 " 0 = MD5",
520 " 5100 = Half MD5",
521 " 100 = SHA1",
522 " 10800 = SHA-384",
523 " 1400 = SHA-256",
524 " 1700 = SHA-512",
525 " 5000 = SHA-3(Keccak)",
526 " 10100 = SipHash",
527 " 6000 = RipeMD160",
528 " 6100 = Whirlpool",
529 " 6900 = GOST R 34.11-94",
530 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
531 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
532 "",
533 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
534 "",
535 " 10 = md5($pass.$salt)",
536 " 20 = md5($salt.$pass)",
537 " 30 = md5(unicode($pass).$salt)",
538 " 40 = md5($salt.unicode($pass))",
539 " 3800 = md5($salt.$pass.$salt)",
540 " 3710 = md5($salt.md5($pass))",
541 " 2600 = md5(md5($pass)",
542 " 4300 = md5(strtoupper(md5($pass)))",
543 " 4400 = md5(sha1($pass))",
544 " 110 = sha1($pass.$salt)",
545 " 120 = sha1($salt.$pass)",
546 " 130 = sha1(unicode($pass).$salt)",
547 " 140 = sha1($salt.unicode($pass))",
548 " 4500 = sha1(sha1($pass)",
549 " 4700 = sha1(md5($pass))",
550 " 4900 = sha1($salt.$pass.$salt)",
551 " 1410 = sha256($pass.$salt)",
552 " 1420 = sha256($salt.$pass)",
553 " 1430 = sha256(unicode($pass).$salt)",
554 " 1440 = sha256($salt.unicode($pass))",
555 " 1710 = sha512($pass.$salt)",
556 " 1720 = sha512($salt.$pass)",
557 " 1730 = sha512(unicode($pass).$salt)",
558 " 1740 = sha512($salt.unicode($pass))",
559 "",
560 "[[ Roll-your-own: Authenticated Hashes ]]",
561 "",
562 " 50 = HMAC-MD5 (key = $pass)",
563 " 60 = HMAC-MD5 (key = $salt)",
564 " 150 = HMAC-SHA1 (key = $pass)",
565 " 160 = HMAC-SHA1 (key = $salt)",
566 " 1450 = HMAC-SHA256 (key = $pass)",
567 " 1460 = HMAC-SHA256 (key = $salt)",
568 " 1750 = HMAC-SHA512 (key = $pass)",
569 " 1760 = HMAC-SHA512 (key = $salt)",
570 "",
571 "[[ Generic KDF ]]",
572 "",
573 " 400 = phpass",
574 " 8900 = scrypt",
575 " 11900 = PBKDF2-HMAC-MD5",
576 " 12000 = PBKDF2-HMAC-SHA1",
577 " 10900 = PBKDF2-HMAC-SHA256",
578 " 12100 = PBKDF2-HMAC-SHA512",
579 "",
580 "[[ Network protocols, Challenge-Response ]]",
581 "",
582 " 23 = Skype",
583 " 2500 = WPA/WPA2",
584 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
585 " 5300 = IKE-PSK MD5",
586 " 5400 = IKE-PSK SHA1",
587 " 5500 = NetNTLMv1",
588 " 5500 = NetNTLMv1 + ESS",
589 " 5600 = NetNTLMv2",
590 " 7300 = IPMI2 RAKP HMAC-SHA1",
591 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
592 " 8300 = DNSSEC (NSEC3)",
593 " 10200 = Cram MD5",
594 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
595 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
596 " 11400 = SIP digest authentication (MD5)",
597 " 13100 = Kerberos 5 TGS-REP etype 23",
598 "",
599 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
600 "",
601 " 121 = SMF (Simple Machines Forum)",
602 " 400 = phpBB3",
603 " 2611 = vBulletin < v3.8.5",
604 " 2711 = vBulletin > v3.8.5",
605 " 2811 = MyBB",
606 " 2811 = IPB (Invison Power Board)",
607 " 8400 = WBB3 (Woltlab Burning Board)",
608 " 11 = Joomla < 2.5.18",
609 " 400 = Joomla > 2.5.18",
610 " 400 = Wordpress",
611 " 2612 = PHPS",
612 " 7900 = Drupal7",
613 " 21 = osCommerce",
614 " 21 = xt:Commerce",
615 " 11000 = PrestaShop",
616 " 124 = Django (SHA-1)",
617 " 10000 = Django (PBKDF2-SHA256)",
618 " 3711 = Mediawiki B type",
619 " 7600 = Redmine",
620 "",
621 "[[ Database Server ]]",
622 "",
623 " 12 = PostgreSQL",
624 " 131 = MSSQL(2000)",
625 " 132 = MSSQL(2005)",
626 " 1731 = MSSQL(2012)",
627 " 1731 = MSSQL(2014)",
628 " 200 = MySQL323",
629 " 300 = MySQL4.1/MySQL5",
630 " 3100 = Oracle H: Type (Oracle 7+)",
631 " 112 = Oracle S: Type (Oracle 11+)",
632 " 12300 = Oracle T: Type (Oracle 12+)",
633 " 8000 = Sybase ASE",
634 "",
635 "[[ HTTP, SMTP, LDAP Server ]]",
636 "",
637 " 141 = EPiServer 6.x < v4",
638 " 1441 = EPiServer 6.x > v4",
639 " 1600 = Apache $apr1$",
640 " 12600 = ColdFusion 10+",
641 " 1421 = hMailServer",
642 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
643 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
644 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
645 "",
646 "[[ Checksums ]]",
647 "",
648 " 11500 = CRC32",
649 "",
650 "[[ Operating-Systems ]]",
651 "",
652 " 3000 = LM",
653 " 1000 = NTLM",
654 " 1100 = Domain Cached Credentials (DCC), MS Cache",
655 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
656 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
657 " 1500 = descrypt, DES(Unix), Traditional DES",
658 " 12400 = BSDiCrypt, Extended DES",
659 " 500 = md5crypt $1$, MD5(Unix)",
660 " 3200 = bcrypt $2*$, Blowfish(Unix)",
661 " 7400 = sha256crypt $5$, SHA256(Unix)",
662 " 1800 = sha512crypt $6$, SHA512(Unix)",
663 " 122 = OSX v10.4",
664 " 122 = OSX v10.5",
665 " 122 = OSX v10.6",
666 " 1722 = OSX v10.7",
667 " 7100 = OSX v10.8",
668 " 7100 = OSX v10.9",
669 " 7100 = OSX v10.10",
670 " 6300 = AIX {smd5}",
671 " 6700 = AIX {ssha1}",
672 " 6400 = AIX {ssha256}",
673 " 6500 = AIX {ssha512}",
674 " 2400 = Cisco-PIX",
675 " 2410 = Cisco-ASA",
676 " 500 = Cisco-IOS $1$",
677 " 5700 = Cisco-IOS $4$",
678 " 9200 = Cisco-IOS $8$",
679 " 9300 = Cisco-IOS $9$",
680 " 22 = Juniper Netscreen/SSG (ScreenOS)",
681 " 501 = Juniper IVE",
682 " 5800 = Android PIN",
683 " 8100 = Citrix Netscaler",
684 " 8500 = RACF",
685 " 7200 = GRUB 2",
686 " 9900 = Radmin2",
687 " 125 = ArubaOS",
688 "",
689 "[[ Enterprise Application Software (EAS) ]]",
690 "",
691 " 7700 = SAP CODVN B (BCODE)",
692 " 7800 = SAP CODVN F/G (PASSCODE)",
693 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
694 " 8600 = Lotus Notes/Domino 5",
695 " 8700 = Lotus Notes/Domino 6",
696 " 9100 = Lotus Notes/Domino 8",
697 " 133 = PeopleSoft",
698 "",
699 "[[ Archives ]]",
700 "",
701 " 11600 = 7-Zip",
702 " 12500 = RAR3-hp",
703 " 13000 = RAR5",
704 " 13200 = AxCrypt",
705 " 13300 = AxCrypt in memory SHA1",
706 "",
707 "[[ Full-Disk encryptions (FDE) ]]",
708 "",
709 " 62XY = TrueCrypt 5.0+",
710 " X = 1 = PBKDF2-HMAC-RipeMD160",
711 " X = 2 = PBKDF2-HMAC-SHA512",
712 " X = 3 = PBKDF2-HMAC-Whirlpool",
713 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
714 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
715 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
716 " Y = 3 = XTS 1536 bit (Ciphers: All)",
717 " 8800 = Android FDE < v4.3",
718 " 12900 = Android FDE (Samsung DEK)",
719 " 12200 = eCryptfs",
720 "",
721 "[[ Documents ]]",
722 "",
723 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
724 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
725 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
726 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
727 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
728 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
729 " 9400 = MS Office 2007",
730 " 9500 = MS Office 2010",
731 " 9600 = MS Office 2013",
732 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
733 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
734 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
735 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
736 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
737 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
738 "",
739 "[[ Password Managers ]]",
740 "",
741 " 9000 = Password Safe v2",
742 " 5200 = Password Safe v3",
743 " 6800 = Lastpass",
744 " 6600 = 1Password, agilekeychain",
745 " 8200 = 1Password, cloudkeychain",
746 " 11300 = Bitcoin/Litecoin wallet.dat",
747 " 12700 = Blockchain, My Wallet",
748 " 13400 = Keepass 1 (AES/Twofish) and Keepass 2 (AES)",
749 "",
750 NULL
751 };
752
753 /**
754 * oclHashcat specific functions
755 */
756
757 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
758 {
759 int exec_pos = (int) device_param->exec_pos - last_num_entries;
760
761 if (exec_pos < 0) exec_pos += EXEC_CACHE;
762
763 double exec_ms_sum = 0;
764
765 int exec_ms_cnt = 0;
766
767 for (int i = 0; i < last_num_entries; i++)
768 {
769 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
770
771 if (exec_ms)
772 {
773 exec_ms_sum += exec_ms;
774
775 exec_ms_cnt++;
776 }
777 }
778
779 if (exec_ms_cnt == 0) return 0;
780
781 return exec_ms_sum / exec_ms_cnt;
782 }
783
784 void status_display_automat ()
785 {
786 FILE *out = stdout;
787
788 fprintf (out, "STATUS\t%u\t", data.devices_status);
789
790 /**
791 * speed new
792 */
793
794 fprintf (out, "SPEED\t");
795
796 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
797 {
798 hc_device_param_t *device_param = &data.devices_param[device_id];
799
800 if (device_param->skipped) continue;
801
802 u64 speed_cnt = 0;
803 float speed_ms = 0;
804
805 for (int i = 0; i < SPEED_CACHE; i++)
806 {
807 float rec_ms;
808
809 hc_timer_get (device_param->speed_rec[i], rec_ms);
810
811 if (rec_ms > SPEED_MAXAGE) continue;
812
813 speed_cnt += device_param->speed_cnt[i];
814 speed_ms += device_param->speed_ms[i];
815 }
816
817 speed_cnt /= SPEED_CACHE;
818 speed_ms /= SPEED_CACHE;
819
820 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
821 }
822
823 /**
824 * exec time
825 */
826
827 fprintf (out, "EXEC_RUNTIME\t");
828
829 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
830 {
831 hc_device_param_t *device_param = &data.devices_param[device_id];
832
833 if (device_param->skipped) continue;
834
835 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
836
837 fprintf (out, "%f\t", exec_ms_avg);
838 }
839
840 /**
841 * words_cur
842 */
843
844 u64 words_cur = get_lowest_words_done ();
845
846 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
847
848 /**
849 * counter
850 */
851
852 u64 progress_total = data.words_cnt * data.salts_cnt;
853
854 u64 all_done = 0;
855 u64 all_rejected = 0;
856 u64 all_restored = 0;
857
858 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
859 {
860 all_done += data.words_progress_done[salt_pos];
861 all_rejected += data.words_progress_rejected[salt_pos];
862 all_restored += data.words_progress_restored[salt_pos];
863 }
864
865 u64 progress_cur = all_restored + all_done + all_rejected;
866 u64 progress_end = progress_total;
867
868 u64 progress_skip = 0;
869
870 if (data.skip)
871 {
872 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
873
874 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
875 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
876 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
877 }
878
879 if (data.limit)
880 {
881 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
882
883 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
884 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
885 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
886 }
887
888 u64 progress_cur_relative_skip = progress_cur - progress_skip;
889 u64 progress_end_relative_skip = progress_end - progress_skip;
890
891 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
892
893 /**
894 * cracks
895 */
896
897 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
898 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
899
900 /**
901 * temperature
902 */
903
904 #ifdef HAVE_HWMON
905 if (data.gpu_temp_disable == 0)
906 {
907 fprintf (out, "TEMP\t");
908
909 hc_thread_mutex_lock (mux_adl);
910
911 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
912 {
913 hc_device_param_t *device_param = &data.devices_param[device_id];
914
915 if (device_param->skipped) continue;
916
917 int temp = hm_get_temperature_with_device_id (device_id);
918
919 fprintf (out, "%d\t", temp);
920 }
921
922 hc_thread_mutex_unlock (mux_adl);
923 }
924 #endif // HAVE_HWMON
925
926 /**
927 * flush
928 */
929
930 #ifdef _WIN
931 fputc ('\r', out);
932 fputc ('\n', out);
933 #endif
934
935 #ifdef _POSIX
936 fputc ('\n', out);
937 #endif
938
939 fflush (out);
940 }
941
942 void status_display ()
943 {
944 if (data.devices_status == STATUS_INIT) return;
945 if (data.devices_status == STATUS_STARTING) return;
946 if (data.devices_status == STATUS_BYPASS) return;
947
948 if (data.status_automat == 1)
949 {
950 status_display_automat ();
951
952 return;
953 }
954
955 char tmp_buf[1000] = { 0 };
956
957 uint tmp_len = 0;
958
959 log_info ("Session.Name...: %s", data.session);
960
961 char *status_type = strstatus (data.devices_status);
962
963 uint hash_mode = data.hash_mode;
964
965 char *hash_type = strhashtype (hash_mode); // not a bug
966
967 log_info ("Status.........: %s", status_type);
968
969 /**
970 * show rules
971 */
972
973 if (data.rp_files_cnt)
974 {
975 uint i;
976
977 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
978 {
979 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
980 }
981
982 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
983
984 log_info ("Rules.Type.....: %s", tmp_buf);
985
986 tmp_len = 0;
987 }
988
989 if (data.rp_gen)
990 {
991 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
992
993 if (data.rp_gen_seed)
994 {
995 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
996 }
997 }
998
999 /**
1000 * show input
1001 */
1002
1003 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1004 {
1005 if (data.wordlist_mode == WL_MODE_FILE)
1006 {
1007 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
1008 }
1009 else if (data.wordlist_mode == WL_MODE_STDIN)
1010 {
1011 log_info ("Input.Mode.....: Pipe");
1012 }
1013 }
1014 else if (data.attack_mode == ATTACK_MODE_COMBI)
1015 {
1016 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1017 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1018 }
1019 else if (data.attack_mode == ATTACK_MODE_BF)
1020 {
1021 char *mask = data.mask;
1022
1023 if (mask != NULL)
1024 {
1025 uint mask_len = data.css_cnt;
1026
1027 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1028
1029 if (mask_len > 0)
1030 {
1031 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1032 {
1033 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1034 {
1035 mask_len -= data.salts_buf[0].salt_len;
1036 }
1037 }
1038
1039 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1040
1041 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1042 }
1043
1044 if (data.maskcnt > 1)
1045 {
1046 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1047
1048 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1049 }
1050
1051 log_info ("Input.Mode.....: %s", tmp_buf);
1052 }
1053
1054 tmp_len = 0;
1055 }
1056 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1057 {
1058 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1059 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1060 }
1061 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1062 {
1063 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1064 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1065 }
1066
1067 if (data.digests_cnt == 1)
1068 {
1069 if (data.hash_mode == 2500)
1070 {
1071 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1072
1073 uint pke[25] = { 0 };
1074
1075 char *pke_ptr = (char *) pke;
1076
1077 for (uint i = 0; i < 25; i++)
1078 {
1079 pke[i] = byte_swap_32 (wpa->pke[i]);
1080 }
1081
1082 char mac1[6] = { 0 };
1083 char mac2[6] = { 0 };
1084
1085 memcpy (mac1, pke_ptr + 23, 6);
1086 memcpy (mac2, pke_ptr + 29, 6);
1087
1088 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1089 (char *) data.salts_buf[0].salt_buf,
1090 mac1[0] & 0xff,
1091 mac1[1] & 0xff,
1092 mac1[2] & 0xff,
1093 mac1[3] & 0xff,
1094 mac1[4] & 0xff,
1095 mac1[5] & 0xff,
1096 mac2[0] & 0xff,
1097 mac2[1] & 0xff,
1098 mac2[2] & 0xff,
1099 mac2[3] & 0xff,
1100 mac2[4] & 0xff,
1101 mac2[5] & 0xff);
1102 }
1103 else if (data.hash_mode == 5200)
1104 {
1105 log_info ("Hash.Target....: File (%s)", data.hashfile);
1106 }
1107 else if (data.hash_mode == 9000)
1108 {
1109 log_info ("Hash.Target....: File (%s)", data.hashfile);
1110 }
1111 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1112 {
1113 log_info ("Hash.Target....: File (%s)", data.hashfile);
1114 }
1115 else
1116 {
1117 char out_buf[HCBUFSIZ] = { 0 };
1118
1119 ascii_digest (out_buf, 0, 0);
1120
1121 // limit length
1122 if (strlen (out_buf) > 40)
1123 {
1124 out_buf[41] = '.';
1125 out_buf[42] = '.';
1126 out_buf[43] = '.';
1127 out_buf[44] = 0;
1128 }
1129
1130 log_info ("Hash.Target....: %s", out_buf);
1131 }
1132 }
1133 else
1134 {
1135 if (data.hash_mode == 3000)
1136 {
1137 char out_buf1[32] = { 0 };
1138 char out_buf2[32] = { 0 };
1139
1140 ascii_digest (out_buf1, 0, 0);
1141 ascii_digest (out_buf2, 0, 1);
1142
1143 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1144 }
1145 else
1146 {
1147 log_info ("Hash.Target....: File (%s)", data.hashfile);
1148 }
1149 }
1150
1151 log_info ("Hash.Type......: %s", hash_type);
1152
1153 /**
1154 * speed new
1155 */
1156
1157 u64 speed_cnt[DEVICES_MAX] = { 0 };
1158 float speed_ms[DEVICES_MAX] = { 0 };
1159
1160 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1161 {
1162 hc_device_param_t *device_param = &data.devices_param[device_id];
1163
1164 if (device_param->skipped) continue;
1165
1166 // we need to clear values (set to 0) because in case the device does
1167 // not get new candidates it idles around but speed display would
1168 // show it as working.
1169 // if we instantly set it to 0 after reading it happens that the
1170 // speed can be shown as zero if the users refreshes too fast.
1171 // therefore, we add a timestamp when a stat was recorded and if its
1172 // too old we will not use it
1173
1174 speed_cnt[device_id] = 0;
1175 speed_ms[device_id] = 0;
1176
1177 for (int i = 0; i < SPEED_CACHE; i++)
1178 {
1179 float rec_ms;
1180
1181 hc_timer_get (device_param->speed_rec[i], rec_ms);
1182
1183 if (rec_ms > SPEED_MAXAGE) continue;
1184
1185 speed_cnt[device_id] += device_param->speed_cnt[i];
1186 speed_ms[device_id] += device_param->speed_ms[i];
1187 }
1188
1189 speed_cnt[device_id] /= SPEED_CACHE;
1190 speed_ms[device_id] /= SPEED_CACHE;
1191 }
1192
1193 float hashes_all_ms = 0;
1194
1195 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1196
1197 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1198 {
1199 hc_device_param_t *device_param = &data.devices_param[device_id];
1200
1201 if (device_param->skipped) continue;
1202
1203 hashes_dev_ms[device_id] = 0;
1204
1205 if (speed_ms[device_id])
1206 {
1207 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1208
1209 hashes_all_ms += hashes_dev_ms[device_id];
1210 }
1211 }
1212
1213 /**
1214 * exec time
1215 */
1216
1217 double exec_all_ms[DEVICES_MAX] = { 0 };
1218
1219 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1220 {
1221 hc_device_param_t *device_param = &data.devices_param[device_id];
1222
1223 if (device_param->skipped) continue;
1224
1225 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1226
1227 exec_all_ms[device_id] = exec_ms_avg;
1228 }
1229
1230 /**
1231 * timers
1232 */
1233
1234 float ms_running = 0;
1235
1236 hc_timer_get (data.timer_running, ms_running);
1237
1238 float ms_paused = data.ms_paused;
1239
1240 if (data.devices_status == STATUS_PAUSED)
1241 {
1242 float ms_paused_tmp = 0;
1243
1244 hc_timer_get (data.timer_paused, ms_paused_tmp);
1245
1246 ms_paused += ms_paused_tmp;
1247 }
1248
1249 #ifdef WIN
1250
1251 __time64_t sec_run = ms_running / 1000;
1252
1253 #else
1254
1255 time_t sec_run = ms_running / 1000;
1256
1257 #endif
1258
1259 if (sec_run)
1260 {
1261 char display_run[32] = { 0 };
1262
1263 struct tm tm_run;
1264
1265 struct tm *tmp = NULL;
1266
1267 #ifdef WIN
1268
1269 tmp = _gmtime64 (&sec_run);
1270
1271 #else
1272
1273 tmp = gmtime (&sec_run);
1274
1275 #endif
1276
1277 if (tmp != NULL)
1278 {
1279 memset (&tm_run, 0, sizeof (tm_run));
1280
1281 memcpy (&tm_run, tmp, sizeof (tm_run));
1282
1283 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1284
1285 char *start = ctime (&data.proc_start);
1286
1287 size_t start_len = strlen (start);
1288
1289 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1290 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1291
1292 log_info ("Time.Started...: %s (%s)", start, display_run);
1293 }
1294 }
1295 else
1296 {
1297 log_info ("Time.Started...: 0 secs");
1298 }
1299
1300 /**
1301 * counters
1302 */
1303
1304 u64 progress_total = data.words_cnt * data.salts_cnt;
1305
1306 u64 all_done = 0;
1307 u64 all_rejected = 0;
1308 u64 all_restored = 0;
1309
1310 u64 progress_noneed = 0;
1311
1312 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1313 {
1314 all_done += data.words_progress_done[salt_pos];
1315 all_rejected += data.words_progress_rejected[salt_pos];
1316 all_restored += data.words_progress_restored[salt_pos];
1317
1318 // Important for ETA only
1319
1320 if (data.salts_shown[salt_pos] == 1)
1321 {
1322 const u64 all = data.words_progress_done[salt_pos]
1323 + data.words_progress_rejected[salt_pos]
1324 + data.words_progress_restored[salt_pos];
1325
1326 const u64 left = data.words_cnt - all;
1327
1328 progress_noneed += left;
1329 }
1330 }
1331
1332 u64 progress_cur = all_restored + all_done + all_rejected;
1333 u64 progress_end = progress_total;
1334
1335 u64 progress_skip = 0;
1336
1337 if (data.skip)
1338 {
1339 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1340
1341 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1342 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1343 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1344 }
1345
1346 if (data.limit)
1347 {
1348 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1349
1350 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1351 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1352 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1353 }
1354
1355 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1356 u64 progress_end_relative_skip = progress_end - progress_skip;
1357
1358 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1359 {
1360 if (data.devices_status != STATUS_CRACKED)
1361 {
1362 #ifdef WIN
1363 __time64_t sec_etc = 0;
1364 #else
1365 time_t sec_etc = 0;
1366 #endif
1367
1368 if (hashes_all_ms)
1369 {
1370 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1371
1372 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1373
1374 sec_etc = ms_left / 1000;
1375 }
1376
1377 if (sec_etc == 0)
1378 {
1379 //log_info ("Time.Estimated.: 0 secs");
1380 }
1381 else if ((u64) sec_etc > ETC_MAX)
1382 {
1383 log_info ("Time.Estimated.: > 10 Years");
1384 }
1385 else
1386 {
1387 char display_etc[32] = { 0 };
1388
1389 struct tm tm_etc;
1390
1391 struct tm *tmp = NULL;
1392
1393 #ifdef WIN
1394
1395 tmp = _gmtime64 (&sec_etc);
1396
1397 #else
1398
1399 tmp = gmtime (&sec_etc);
1400
1401 #endif
1402
1403 if (tmp != NULL)
1404 {
1405 memset (&tm_etc, 0, sizeof (tm_etc));
1406
1407 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1408
1409 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1410
1411 time_t now;
1412
1413 time (&now);
1414
1415 now += sec_etc;
1416
1417 char *etc = ctime (&now);
1418
1419 size_t etc_len = strlen (etc);
1420
1421 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1422 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1423
1424 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1425 }
1426 }
1427 }
1428 }
1429
1430 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1431 {
1432 hc_device_param_t *device_param = &data.devices_param[device_id];
1433
1434 if (device_param->skipped) continue;
1435
1436 char display_dev_cur[16] = { 0 };
1437
1438 strncpy (display_dev_cur, "0.00", 4);
1439
1440 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1441
1442 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1443 }
1444
1445 char display_all_cur[16] = { 0 };
1446
1447 strncpy (display_all_cur, "0.00", 4);
1448
1449 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1450
1451 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1452
1453 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1454 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1455
1456 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);
1457
1458 // crack-per-time
1459
1460 if (data.digests_cnt > 100)
1461 {
1462 time_t now = time (NULL);
1463
1464 int cpt_cur_min = 0;
1465 int cpt_cur_hour = 0;
1466 int cpt_cur_day = 0;
1467
1468 for (int i = 0; i < CPT_BUF; i++)
1469 {
1470 const uint cracked = data.cpt_buf[i].cracked;
1471 const time_t timestamp = data.cpt_buf[i].timestamp;
1472
1473 if ((timestamp + 60) > now)
1474 {
1475 cpt_cur_min += cracked;
1476 }
1477
1478 if ((timestamp + 3600) > now)
1479 {
1480 cpt_cur_hour += cracked;
1481 }
1482
1483 if ((timestamp + 86400) > now)
1484 {
1485 cpt_cur_day += cracked;
1486 }
1487 }
1488
1489 float ms_real = ms_running - ms_paused;
1490
1491 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1492 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1493 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1494
1495 if ((data.cpt_start + 86400) < now)
1496 {
1497 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1498 cpt_cur_min,
1499 cpt_cur_hour,
1500 cpt_cur_day,
1501 cpt_avg_min,
1502 cpt_avg_hour,
1503 cpt_avg_day);
1504 }
1505 else if ((data.cpt_start + 3600) < now)
1506 {
1507 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1508 cpt_cur_min,
1509 cpt_cur_hour,
1510 cpt_avg_min,
1511 cpt_avg_hour,
1512 cpt_avg_day);
1513 }
1514 else if ((data.cpt_start + 60) < now)
1515 {
1516 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1517 cpt_cur_min,
1518 cpt_avg_min,
1519 cpt_avg_hour,
1520 cpt_avg_day);
1521 }
1522 else
1523 {
1524 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1525 cpt_avg_min,
1526 cpt_avg_hour,
1527 cpt_avg_day);
1528 }
1529 }
1530
1531 // Restore point
1532
1533 u64 restore_point = get_lowest_words_done ();
1534
1535 u64 restore_total = data.words_base;
1536
1537 float percent_restore = 0;
1538
1539 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1540
1541 if (progress_end_relative_skip)
1542 {
1543 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1544 {
1545 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1546 float percent_rejected = 0.0;
1547
1548 if (progress_cur)
1549 {
1550 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1551 }
1552
1553 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);
1554 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1555
1556 if (data.restore_disable == 0)
1557 {
1558 if (percent_finished != 1)
1559 {
1560 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1561 }
1562 }
1563 }
1564 }
1565 else
1566 {
1567 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1568 {
1569 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1570 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1571
1572 if (data.restore_disable == 0)
1573 {
1574 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1575 }
1576 }
1577 else
1578 {
1579 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1580 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1581
1582 // --restore not allowed if stdin is used -- really? why?
1583
1584 //if (data.restore_disable == 0)
1585 //{
1586 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1587 //}
1588 }
1589 }
1590
1591 #ifdef HAVE_HWMON
1592 if (data.gpu_temp_disable == 0)
1593 {
1594 hc_thread_mutex_lock (mux_adl);
1595
1596 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1597 {
1598 hc_device_param_t *device_param = &data.devices_param[device_id];
1599
1600 if (device_param->skipped) continue;
1601
1602 #define HM_STR_BUF_SIZE 255
1603
1604 if (data.hm_device[device_id].fan_supported == 1)
1605 {
1606 char utilization[HM_STR_BUF_SIZE] = { 0 };
1607 char temperature[HM_STR_BUF_SIZE] = { 0 };
1608 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1609
1610 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1611 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1612
1613 if (device_param->vendor_id == VENDOR_ID_AMD)
1614 {
1615 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1616 }
1617 else if (device_param->vendor_id == VENDOR_ID_NV)
1618 {
1619 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1620 }
1621
1622 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1623 }
1624 else
1625 {
1626 char utilization[HM_STR_BUF_SIZE] = { 0 };
1627 char temperature[HM_STR_BUF_SIZE] = { 0 };
1628
1629 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1630 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1631
1632 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1633 }
1634 }
1635
1636 hc_thread_mutex_unlock (mux_adl);
1637 }
1638 #endif // HAVE_HWMON
1639 }
1640
1641 static void status_benchmark ()
1642 {
1643 if (data.devices_status == STATUS_INIT) return;
1644 if (data.devices_status == STATUS_STARTING) return;
1645
1646 if (data.words_cnt == 0) return;
1647
1648 u64 speed_cnt[DEVICES_MAX] = { 0 };
1649 float speed_ms[DEVICES_MAX] = { 0 };
1650
1651 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1652 {
1653 hc_device_param_t *device_param = &data.devices_param[device_id];
1654
1655 if (device_param->skipped) continue;
1656
1657 speed_cnt[device_id] = 0;
1658 speed_ms[device_id] = 0;
1659
1660 for (int i = 0; i < SPEED_CACHE; i++)
1661 {
1662 speed_cnt[device_id] += device_param->speed_cnt[i];
1663 speed_ms[device_id] += device_param->speed_ms[i];
1664 }
1665
1666 speed_cnt[device_id] /= SPEED_CACHE;
1667 speed_ms[device_id] /= SPEED_CACHE;
1668 }
1669
1670 float hashes_all_ms = 0;
1671
1672 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1673
1674 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1675 {
1676 hc_device_param_t *device_param = &data.devices_param[device_id];
1677
1678 if (device_param->skipped) continue;
1679
1680 hashes_dev_ms[device_id] = 0;
1681
1682 if (speed_ms[device_id])
1683 {
1684 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1685
1686 hashes_all_ms += hashes_dev_ms[device_id];
1687 }
1688 }
1689
1690 /**
1691 * exec time
1692 */
1693
1694 double exec_all_ms[DEVICES_MAX] = { 0 };
1695
1696 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1697 {
1698 hc_device_param_t *device_param = &data.devices_param[device_id];
1699
1700 if (device_param->skipped) continue;
1701
1702 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1703
1704 exec_all_ms[device_id] = exec_ms_avg;
1705 }
1706
1707 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1708 {
1709 hc_device_param_t *device_param = &data.devices_param[device_id];
1710
1711 if (device_param->skipped) continue;
1712
1713 char display_dev_cur[16] = { 0 };
1714
1715 strncpy (display_dev_cur, "0.00", 4);
1716
1717 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1718
1719 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1720 }
1721
1722 char display_all_cur[16] = { 0 };
1723
1724 strncpy (display_all_cur, "0.00", 4);
1725
1726 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1727
1728 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1729 }
1730
1731 /**
1732 * oclHashcat -only- functions
1733 */
1734
1735 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1736 {
1737 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1738 {
1739 if (attack_kern == ATTACK_KERN_STRAIGHT)
1740 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1741 else if (attack_kern == ATTACK_KERN_COMBI)
1742 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1743 else if (attack_kern == ATTACK_KERN_BF)
1744 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1745 }
1746 else
1747 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1748 }
1749
1750 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)
1751 {
1752 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1753 {
1754 if (attack_kern == ATTACK_KERN_STRAIGHT)
1755 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1756 else if (attack_kern == ATTACK_KERN_COMBI)
1757 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1758 else if (attack_kern == ATTACK_KERN_BF)
1759 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1760 }
1761 else
1762 {
1763 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1764 }
1765 }
1766
1767 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1768 {
1769 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1770 {
1771 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1772 }
1773 else
1774 {
1775 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1776 }
1777 }
1778
1779 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)
1780 {
1781 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1782 {
1783 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1784 }
1785 else
1786 {
1787 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1788 }
1789 }
1790
1791 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1792 {
1793 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1794 }
1795
1796 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1797 {
1798 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1799 }
1800
1801 static uint convert_from_hex (char *line_buf, const uint line_len)
1802 {
1803 if (line_len & 1) return (line_len); // not in hex
1804
1805 if (data.hex_wordlist == 1)
1806 {
1807 uint i;
1808 uint j;
1809
1810 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1811 {
1812 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1813 }
1814
1815 memset (line_buf + i, 0, line_len - i);
1816
1817 return (i);
1818 }
1819 else if (line_len >= 6) // $HEX[] = 6
1820 {
1821 if (line_buf[0] != '$') return (line_len);
1822 if (line_buf[1] != 'H') return (line_len);
1823 if (line_buf[2] != 'E') return (line_len);
1824 if (line_buf[3] != 'X') return (line_len);
1825 if (line_buf[4] != '[') return (line_len);
1826 if (line_buf[line_len - 1] != ']') return (line_len);
1827
1828 uint i;
1829 uint j;
1830
1831 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1832 {
1833 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1834 }
1835
1836 memset (line_buf + i, 0, line_len - i);
1837
1838 return (i);
1839 }
1840
1841 return (line_len);
1842 }
1843
1844 static void clear_prompt ()
1845 {
1846 fputc ('\r', stdout);
1847
1848 for (size_t i = 0; i < strlen (PROMPT); i++)
1849 {
1850 fputc (' ', stdout);
1851 }
1852
1853 fputc ('\r', stdout);
1854
1855 fflush (stdout);
1856 }
1857
1858 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1859 {
1860 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);
1861 }
1862
1863 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1864 {
1865 char *outfile = data.outfile;
1866 uint quiet = data.quiet;
1867 FILE *pot_fp = data.pot_fp;
1868 uint loopback = data.loopback;
1869 uint debug_mode = data.debug_mode;
1870 char *debug_file = data.debug_file;
1871
1872 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1873 int debug_rule_len = 0; // -1 error
1874 uint debug_plain_len = 0;
1875
1876 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1877
1878 // hash
1879
1880 char out_buf[HCBUFSIZ] = { 0 };
1881
1882 ascii_digest (out_buf, salt_pos, digest_pos);
1883
1884 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1885
1886 // plain
1887
1888 plain_t plain;
1889
1890 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);
1891
1892 uint gidvid = plain.gidvid;
1893 uint il_pos = plain.il_pos;
1894
1895 u64 crackpos = device_param->words_off;
1896
1897 uint plain_buf[16] = { 0 };
1898
1899 u8 *plain_ptr = (u8 *) plain_buf;
1900 unsigned int plain_len = 0;
1901
1902 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1903 {
1904 u64 gidd = gidvid;
1905 u64 gidm = 0;
1906
1907 pw_t pw;
1908
1909 gidd_to_pw_t (device_param, gidd, &pw);
1910
1911 for (int i = 0, j = gidm; i < 16; i++, j++)
1912 {
1913 plain_buf[i] = pw.i[j];
1914 }
1915
1916 plain_len = pw.pw_len;
1917
1918 const uint off = device_param->innerloop_pos + il_pos;
1919
1920 if (debug_mode > 0)
1921 {
1922 debug_rule_len = 0;
1923
1924 // save rule
1925 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1926 {
1927 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1928
1929 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1930 }
1931
1932 // save plain
1933 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1934 {
1935 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1936
1937 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1938
1939 debug_plain_len = plain_len;
1940 }
1941 }
1942
1943 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1944
1945 crackpos += gidvid;
1946 crackpos *= data.kernel_rules_cnt;
1947 crackpos += device_param->innerloop_pos + il_pos;
1948
1949 if (plain_len > data.pw_max) plain_len = data.pw_max;
1950 }
1951 else if (data.attack_mode == ATTACK_MODE_COMBI)
1952 {
1953 u64 gidd = gidvid;
1954 u64 gidm = 0;
1955
1956 pw_t pw;
1957
1958 gidd_to_pw_t (device_param, gidd, &pw);
1959
1960 for (int i = 0, j = gidm; i < 16; i++, j++)
1961 {
1962 plain_buf[i] = pw.i[j];
1963 }
1964
1965 plain_len = pw.pw_len;
1966
1967 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1968 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1969
1970 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1971 {
1972 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1973 }
1974 else
1975 {
1976 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1977
1978 memcpy (plain_ptr, comb_buf, comb_len);
1979 }
1980
1981 plain_len += comb_len;
1982
1983 crackpos += gidvid;
1984 crackpos *= data.combs_cnt;
1985 crackpos += device_param->innerloop_pos + il_pos;
1986
1987 if (data.pw_max != PW_DICTMAX1)
1988 {
1989 if (plain_len > data.pw_max) plain_len = data.pw_max;
1990 }
1991 }
1992 else if (data.attack_mode == ATTACK_MODE_BF)
1993 {
1994 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1995 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1996
1997 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1998 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1999
2000 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2001 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2002
2003 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2004 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2005
2006 plain_len = data.css_cnt;
2007
2008 crackpos += gidvid;
2009 crackpos *= data.bfs_cnt;
2010 crackpos += device_param->innerloop_pos + il_pos;
2011 }
2012 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2013 {
2014 u64 gidd = gidvid;
2015 u64 gidm = 0;
2016
2017 pw_t pw;
2018
2019 gidd_to_pw_t (device_param, gidd, &pw);
2020
2021 for (int i = 0, j = gidm; i < 16; i++, j++)
2022 {
2023 plain_buf[i] = pw.i[j];
2024 }
2025
2026 plain_len = pw.pw_len;
2027
2028 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2029
2030 uint start = 0;
2031 uint stop = device_param->kernel_params_mp_buf32[4];
2032
2033 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2034
2035 plain_len += start + stop;
2036
2037 crackpos += gidvid;
2038 crackpos *= data.combs_cnt;
2039 crackpos += device_param->innerloop_pos + il_pos;
2040
2041 if (data.pw_max != PW_DICTMAX1)
2042 {
2043 if (plain_len > data.pw_max) plain_len = data.pw_max;
2044 }
2045 }
2046 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2047 {
2048 u64 gidd = gidvid;
2049 u64 gidm = 0;
2050
2051 pw_t pw;
2052
2053 gidd_to_pw_t (device_param, gidd, &pw);
2054
2055 for (int i = 0, j = gidm; i < 16; i++, j++)
2056 {
2057 plain_buf[i] = pw.i[j];
2058 }
2059
2060 plain_len = pw.pw_len;
2061
2062 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2063
2064 uint start = 0;
2065 uint stop = device_param->kernel_params_mp_buf32[4];
2066
2067 memmove (plain_ptr + stop, plain_ptr, plain_len);
2068
2069 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2070
2071 plain_len += start + stop;
2072
2073 crackpos += gidvid;
2074 crackpos *= data.combs_cnt;
2075 crackpos += device_param->innerloop_pos + il_pos;
2076
2077 if (data.pw_max != PW_DICTMAX1)
2078 {
2079 if (plain_len > data.pw_max) plain_len = data.pw_max;
2080 }
2081 }
2082
2083 if (data.attack_mode == ATTACK_MODE_BF)
2084 {
2085 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2086 {
2087 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2088 {
2089 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2090 {
2091 plain_len = plain_len - data.salts_buf[0].salt_len;
2092 }
2093 }
2094
2095 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2096 {
2097 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2098 {
2099 plain_ptr[j] = plain_ptr[i];
2100 }
2101
2102 plain_len = plain_len / 2;
2103 }
2104 }
2105 }
2106
2107 // if enabled, update also the potfile
2108
2109 if (pot_fp)
2110 {
2111 lock_file (pot_fp);
2112
2113 fprintf (pot_fp, "%s:", out_buf);
2114
2115 format_plain (pot_fp, plain_ptr, plain_len, 1);
2116
2117 fputc ('\n', pot_fp);
2118
2119 fflush (pot_fp);
2120
2121 unlock_file (pot_fp);
2122 }
2123
2124 // outfile
2125
2126 FILE *out_fp = NULL;
2127
2128 if (outfile != NULL)
2129 {
2130 if ((out_fp = fopen (outfile, "ab")) == NULL)
2131 {
2132 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2133
2134 out_fp = stdout;
2135 }
2136 lock_file (out_fp);
2137 }
2138 else
2139 {
2140 out_fp = stdout;
2141
2142 if (quiet == 0) clear_prompt ();
2143 }
2144
2145 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2146
2147 if (outfile != NULL)
2148 {
2149 if (out_fp != stdout)
2150 {
2151 fclose (out_fp);
2152 }
2153 }
2154 else
2155 {
2156 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2157 {
2158 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2159 {
2160 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2161 if (quiet == 0) fflush (stdout);
2162 }
2163 }
2164 }
2165
2166 // loopback
2167
2168 if (loopback)
2169 {
2170 char *loopback_file = data.loopback_file;
2171
2172 FILE *fb_fp = NULL;
2173
2174 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2175 {
2176 lock_file (fb_fp);
2177
2178 format_plain (fb_fp, plain_ptr, plain_len, 1);
2179
2180 fputc ('\n', fb_fp);
2181
2182 fclose (fb_fp);
2183 }
2184 }
2185
2186 // (rule) debug mode
2187
2188 // the next check implies that:
2189 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2190 // - debug_mode > 0
2191
2192 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2193 {
2194 if (debug_rule_len < 0) debug_rule_len = 0;
2195
2196 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2197
2198 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2199
2200 if ((quiet == 0) && (debug_file == NULL))
2201 {
2202 fprintf (stdout, "%s", PROMPT);
2203 fflush (stdout);
2204 }
2205 }
2206 }
2207
2208 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2209 {
2210 salt_t *salt_buf = &data.salts_buf[salt_pos];
2211
2212 int found = 0;
2213
2214 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);
2215
2216 for (uint i = 0; i < KERNEL_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2217
2218 if (found == 1)
2219 {
2220 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2221
2222 log_info_nn ("");
2223
2224 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);
2225
2226 uint cpt_cracked = 0;
2227
2228 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2229 {
2230 uint idx = salt_buf->digests_offset + digest_pos;
2231
2232 if (data.digests_shown_tmp[idx] == 0) continue;
2233
2234 if (data.digests_shown[idx] == 1) continue;
2235
2236 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2237 {
2238 data.digests_shown[idx] = 1;
2239
2240 data.digests_done++;
2241
2242 cpt_cracked++;
2243
2244 salt_buf->digests_done++;
2245
2246 if (salt_buf->digests_done == salt_buf->digests_cnt)
2247 {
2248 data.salts_shown[salt_pos] = 1;
2249
2250 data.salts_done++;
2251 }
2252 }
2253
2254 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2255
2256 check_hash (device_param, salt_pos, digest_pos);
2257 }
2258
2259 if (cpt_cracked > 0)
2260 {
2261 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2262 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2263
2264 data.cpt_pos++;
2265
2266 data.cpt_total += cpt_cracked;
2267
2268 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2269 }
2270
2271 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2272 {
2273 // we need to reset cracked state on the device
2274 // otherwise host thinks again and again the hash was cracked
2275 // and returns invalid password each time
2276
2277 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2278
2279 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);
2280 }
2281
2282 memset (device_param->result, 0, device_param->size_results);
2283
2284 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);
2285 }
2286 }
2287
2288 static void save_hash ()
2289 {
2290 char *hashfile = data.hashfile;
2291
2292 char new_hashfile[256] = { 0 };
2293 char old_hashfile[256] = { 0 };
2294
2295 snprintf (new_hashfile, 255, "%s.new", hashfile);
2296 snprintf (old_hashfile, 255, "%s.old", hashfile);
2297
2298 unlink (new_hashfile);
2299
2300 char separator = data.separator;
2301
2302 FILE *fp = fopen (new_hashfile, "wb");
2303
2304 if (fp == NULL)
2305 {
2306 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2307
2308 exit (-1);
2309 }
2310
2311 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2312 {
2313 if (data.salts_shown[salt_pos] == 1) continue;
2314
2315 salt_t *salt_buf = &data.salts_buf[salt_pos];
2316
2317 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2318 {
2319 uint idx = salt_buf->digests_offset + digest_pos;
2320
2321 if (data.digests_shown[idx] == 1) continue;
2322
2323 if (data.hash_mode != 2500)
2324 {
2325 char out_buf[HCBUFSIZ] = { 0 };
2326
2327 if (data.username == 1)
2328 {
2329 user_t *user = data.hash_info[idx]->user;
2330
2331 uint i;
2332
2333 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2334
2335 fputc (separator, fp);
2336 }
2337
2338 ascii_digest (out_buf, salt_pos, digest_pos);
2339
2340 fputs (out_buf, fp);
2341
2342 log_out (fp, "");
2343 }
2344 else
2345 {
2346 hccap_t hccap;
2347
2348 to_hccap_t (&hccap, salt_pos, digest_pos);
2349
2350 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2351 }
2352 }
2353 }
2354
2355 fflush (fp);
2356
2357 fclose (fp);
2358
2359 unlink (old_hashfile);
2360
2361 if (rename (hashfile, old_hashfile) != 0)
2362 {
2363 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2364
2365 exit (-1);
2366 }
2367
2368 unlink (hashfile);
2369
2370 if (rename (new_hashfile, hashfile) != 0)
2371 {
2372 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2373
2374 exit (-1);
2375 }
2376
2377 unlink (old_hashfile);
2378 }
2379
2380 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2381 {
2382 // function called only in case kernel_power_all > words_left
2383
2384 float kernel_power_div = (float) (total_left) / kernel_power_all;
2385
2386 kernel_power_div += kernel_power_div / 100;
2387
2388 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2389
2390 while (kernel_power_new < total_left)
2391 {
2392 kernel_power_div += kernel_power_div / 100;
2393
2394 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2395 }
2396
2397 if (data.quiet == 0)
2398 {
2399 clear_prompt ();
2400
2401 log_info ("");
2402
2403 log_info ("INFO: approaching final keyspace, workload adjusted");
2404
2405 log_info ("");
2406
2407 fprintf (stdout, "%s", PROMPT);
2408
2409 fflush (stdout);
2410 }
2411
2412 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2413
2414 return kernel_power_div;
2415 }
2416
2417 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2418 {
2419 uint num_elements = num;
2420
2421 device_param->kernel_params_buf32[30] = data.combs_mode;
2422 device_param->kernel_params_buf32[31] = num;
2423
2424 uint kernel_threads = device_param->kernel_threads;
2425
2426 while (num_elements % kernel_threads) num_elements++;
2427
2428 cl_kernel kernel = NULL;
2429
2430 switch (kern_run)
2431 {
2432 case KERN_RUN_1: kernel = device_param->kernel1; break;
2433 case KERN_RUN_12: kernel = device_param->kernel12; break;
2434 case KERN_RUN_2: kernel = device_param->kernel2; break;
2435 case KERN_RUN_23: kernel = device_param->kernel23; break;
2436 case KERN_RUN_3: kernel = device_param->kernel3; break;
2437 }
2438
2439 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2440 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2441 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2442 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2443 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2444 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2445 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2446 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2447 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2448 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2449 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2450
2451 hc_timer_t timer;
2452
2453 hc_timer_set (&timer);
2454
2455 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2456 {
2457 const size_t global_work_size[3] = { num_elements, 32, 1 };
2458 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2459
2460 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2461 }
2462 else
2463 {
2464 size_t workgroup_size = 0;
2465
2466 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2467
2468 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2469
2470 const size_t global_work_size[3] = { num_elements, 1, 1 };
2471 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2472
2473 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2474 }
2475
2476 hc_clFlush (data.ocl, device_param->command_queue);
2477
2478 hc_clFinish (data.ocl, device_param->command_queue);
2479
2480 if (event_update)
2481 {
2482 float exec_time;
2483
2484 hc_timer_get (timer, exec_time);
2485
2486 uint exec_pos = device_param->exec_pos;
2487
2488 device_param->exec_ms[exec_pos] = exec_time;
2489
2490 exec_pos++;
2491
2492 if (exec_pos == EXEC_CACHE)
2493 {
2494 exec_pos = 0;
2495 }
2496
2497 device_param->exec_pos = exec_pos;
2498 }
2499 }
2500
2501 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2502 {
2503 uint num_elements = num;
2504
2505 switch (kern_run)
2506 {
2507 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2508 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2509 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2510 }
2511
2512 // causes problems with special threads like in bcrypt
2513 // const uint kernel_threads = device_param->kernel_threads;
2514
2515 uint kernel_threads = KERNEL_THREADS;
2516
2517 while (num_elements % kernel_threads) num_elements++;
2518
2519 cl_kernel kernel = NULL;
2520
2521 switch (kern_run)
2522 {
2523 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2524 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2525 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2526 }
2527
2528 switch (kern_run)
2529 {
2530 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2531 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2532 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2533 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2534 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2535 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2536 break;
2537 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2538 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2539 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2540 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2541 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2542 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2543 break;
2544 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2545 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2546 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2547 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2548 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2549 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2550 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2551 break;
2552 }
2553
2554 size_t workgroup_size = 0;
2555 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), &workgroup_size, NULL);
2556 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2557
2558 const size_t global_work_size[3] = { num_elements, 1, 1 };
2559 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2560
2561 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2562
2563 hc_clFlush (data.ocl, device_param->command_queue);
2564
2565 hc_clFinish (data.ocl, device_param->command_queue);
2566 }
2567
2568 static void run_kernel_tm (hc_device_param_t *device_param)
2569 {
2570 const uint num_elements = 1024; // fixed
2571
2572 uint kernel_threads = 32;
2573
2574 cl_kernel kernel = device_param->kernel_tm;
2575
2576 size_t workgroup_size = 0;
2577 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2578 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2579
2580 const size_t global_work_size[3] = { num_elements, 1, 1 };
2581 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2582
2583 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2584
2585 hc_clFlush (data.ocl, device_param->command_queue);
2586
2587 hc_clFinish (data.ocl, device_param->command_queue);
2588 }
2589
2590 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2591 {
2592 uint num_elements = num;
2593
2594 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2595 device_param->kernel_params_amp_buf32[6] = num_elements;
2596
2597 // causes problems with special threads like in bcrypt
2598 // const uint kernel_threads = device_param->kernel_threads;
2599
2600 uint kernel_threads = KERNEL_THREADS;
2601
2602 while (num_elements % kernel_threads) num_elements++;
2603
2604 cl_kernel kernel = device_param->kernel_amp;
2605
2606 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2607 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2608
2609 size_t workgroup_size = 0;
2610 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2611 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2612
2613 const size_t global_work_size[3] = { num_elements, 1, 1 };
2614 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2615
2616 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2617
2618 hc_clFlush (data.ocl, device_param->command_queue);
2619
2620 hc_clFinish (data.ocl, device_param->command_queue);
2621 }
2622
2623 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2624 {
2625 int rc = -1;
2626
2627 if (device_param->opencl_v12 && device_param->vendor_id == VENDOR_ID_AMD)
2628 {
2629 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2630
2631 const cl_uchar zero = 0;
2632
2633 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2634 }
2635
2636 if (rc != 0)
2637 {
2638 // NOTE: clEnqueueFillBuffer () always fails with -59
2639 // IOW, it's not supported by Nvidia ForceWare <= 352.21, also pocl segfaults, also on apple
2640 // How's that possible, OpenCL 1.2 support is advertised??
2641 // We need to workaround...
2642
2643 #define FILLSZ 0x100000
2644
2645 char *tmp = (char *) mymalloc (FILLSZ);
2646
2647 for (uint i = 0; i < size; i += FILLSZ)
2648 {
2649 const int left = size - i;
2650
2651 const int fillsz = MIN (FILLSZ, left);
2652
2653 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2654 }
2655
2656 myfree (tmp);
2657 }
2658 }
2659
2660 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)
2661 {
2662 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2663 {
2664 if (attack_mode == ATTACK_MODE_BF)
2665 {
2666 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2667 {
2668 const uint size_tm = 32 * sizeof (bs_word_t);
2669
2670 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2671
2672 run_kernel_tm (device_param);
2673
2674 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);
2675 }
2676 }
2677
2678 if (highest_pw_len < 16)
2679 {
2680 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2681 }
2682 else if (highest_pw_len < 32)
2683 {
2684 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2685 }
2686 else
2687 {
2688 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2689 }
2690 }
2691 else
2692 {
2693 run_kernel_amp (device_param, pws_cnt);
2694
2695 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2696
2697 if (opts_type & OPTS_TYPE_HOOK12)
2698 {
2699 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2700 }
2701
2702 uint iter = salt_buf->salt_iter;
2703
2704 uint loop_step = device_param->kernel_loops;
2705
2706 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2707 {
2708 uint loop_left = iter - loop_pos;
2709
2710 loop_left = MIN (loop_left, loop_step);
2711
2712 device_param->kernel_params_buf32[25] = loop_pos;
2713 device_param->kernel_params_buf32[26] = loop_left;
2714
2715 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2716
2717 if (data.devices_status == STATUS_CRACKED) break;
2718 if (data.devices_status == STATUS_ABORTED) break;
2719 if (data.devices_status == STATUS_QUIT) break;
2720 }
2721
2722 if (opts_type & OPTS_TYPE_HOOK23)
2723 {
2724 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2725
2726 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);
2727
2728 // do something with data
2729
2730 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);
2731 }
2732
2733 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2734 }
2735 }
2736
2737 static int run_rule_engine (const int rule_len, const char *rule_buf)
2738 {
2739 if (rule_len == 0)
2740 {
2741 return 0;
2742 }
2743 else if (rule_len == 1)
2744 {
2745 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2746 }
2747
2748 return 1;
2749 }
2750
2751 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2752 {
2753 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2754 {
2755 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);
2756 }
2757 else if (data.attack_kern == ATTACK_KERN_COMBI)
2758 {
2759 if (data.attack_mode == ATTACK_MODE_HYBRID2)
2760 {
2761 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2762 {
2763 for (u32 i = 0; i < pws_cnt; i++)
2764 {
2765 const u32 pw_len = device_param->pws_buf[i].pw_len;
2766
2767 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2768
2769 ptr[pw_len] = 0x01;
2770 }
2771 }
2772 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2773 {
2774 for (u32 i = 0; i < pws_cnt; i++)
2775 {
2776 const u32 pw_len = device_param->pws_buf[i].pw_len;
2777
2778 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2779
2780 ptr[pw_len] = 0x80;
2781 }
2782 }
2783 }
2784
2785 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);
2786 }
2787 else if (data.attack_kern == ATTACK_KERN_BF)
2788 {
2789 const u64 off = device_param->words_off;
2790
2791 device_param->kernel_params_mp_l_buf64[3] = off;
2792
2793 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2794 }
2795 }
2796
2797 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops, const int repeat)
2798 {
2799 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2800
2801 device_param->kernel_params_buf32[26] = kernel_loops;
2802 device_param->kernel_params_buf32[27] = kernel_loops;
2803
2804 // init some fake words
2805
2806 for (u32 i = 0; i < kernel_power; i++)
2807 {
2808 device_param->pws_buf[i].i[0] = i;
2809 device_param->pws_buf[i].i[1] = 0x01234567;
2810 device_param->pws_buf[i].pw_len = 4 + (i & 3);
2811 }
2812
2813 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);
2814
2815 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2816 {
2817 run_kernel_amp (device_param, kernel_power);
2818 }
2819
2820 // caching run
2821
2822 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2823 {
2824 run_kernel (KERN_RUN_1, device_param, kernel_power, false);
2825 }
2826 else
2827 {
2828 run_kernel (KERN_RUN_2, device_param, kernel_power, false);
2829 }
2830
2831 // now user repeats
2832
2833 for (int i = 0; i < repeat; i++)
2834 {
2835 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2836 {
2837 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2838 }
2839 else
2840 {
2841 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2842 }
2843 }
2844
2845 const double exec_ms_prev = get_avg_exec_time (device_param, repeat);
2846
2847 // reset fake words
2848
2849 memset (device_param->pws_buf, 0, kernel_power * sizeof (pw_t));
2850
2851 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);
2852 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);
2853
2854 return exec_ms_prev;
2855 }
2856
2857 static void autotune (hc_device_param_t *device_param)
2858 {
2859 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2860
2861 const u32 kernel_accel_min = device_param->kernel_accel_min;
2862 const u32 kernel_accel_max = device_param->kernel_accel_max;
2863
2864 const u32 kernel_loops_min = device_param->kernel_loops_min;
2865 const u32 kernel_loops_max = device_param->kernel_loops_max;
2866
2867 u32 kernel_accel = kernel_accel_min;
2868 u32 kernel_loops = kernel_loops_min;
2869
2870 // steps
2871
2872 #define STEPS_CNT 10
2873
2874 #define STEPS_ACCEL_CNT (STEPS_CNT + 2)
2875 #define STEPS_LOOPS_CNT (STEPS_CNT + 2)
2876
2877 u32 steps_accel[STEPS_ACCEL_CNT];
2878 u32 steps_loops[STEPS_LOOPS_CNT];
2879
2880 for (int i = 0; i < STEPS_ACCEL_CNT; i++)
2881 {
2882 steps_accel[i] = 1 << i;
2883 }
2884
2885 for (int i = 0; i < STEPS_LOOPS_CNT; i++)
2886 {
2887 steps_loops[i] = 1 << i;
2888 }
2889
2890 steps_accel[STEPS_CNT + 0] = kernel_accel_min;
2891 steps_accel[STEPS_CNT + 1] = kernel_accel_max;
2892
2893 steps_loops[STEPS_CNT + 0] = kernel_loops_min;
2894 steps_loops[STEPS_CNT + 1] = kernel_loops_max;
2895
2896 qsort (steps_accel, STEPS_ACCEL_CNT, sizeof (u32), sort_by_u32);
2897 qsort (steps_loops, STEPS_LOOPS_CNT, sizeof (u32), sort_by_u32);
2898
2899 // find out highest kernel-loops that stays below target_ms, we can use it later for multiplication as this is a linear function
2900
2901 u32 kernel_loops_tmp;
2902
2903 for (kernel_loops_tmp = kernel_loops_max; kernel_loops_tmp > kernel_loops_min; kernel_loops_tmp >>= 1)
2904 {
2905 const double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops_tmp, 1);
2906
2907 if (exec_ms < target_ms) break;
2908 }
2909
2910 // kernel-accel
2911
2912 if (kernel_accel_min < kernel_accel_max)
2913 {
2914 double e_best = 0;
2915
2916 for (int i = 0; i < STEPS_ACCEL_CNT; i++)
2917 {
2918 const u32 kernel_accel_try = steps_accel[i];
2919
2920 if (kernel_accel_try < kernel_accel_min) continue;
2921 if (kernel_accel_try > kernel_accel_max) break;
2922
2923 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_tmp, 1);
2924
2925 if (exec_ms > target_ms) break;
2926
2927 const double e = kernel_accel_try / exec_ms;
2928
2929 if (e > e_best)
2930 {
2931 kernel_accel = kernel_accel_try;
2932
2933 e_best = e;
2934 }
2935 }
2936 }
2937
2938 // kernel-loops final
2939
2940 if (kernel_loops_min < kernel_loops_max)
2941 {
2942 double e_best = 0;
2943
2944 for (int i = 0; i < STEPS_LOOPS_CNT; i++)
2945 {
2946 const u32 kernel_loops_try = steps_loops[i];
2947
2948 if (kernel_loops_try < kernel_loops_min) continue;
2949 if (kernel_loops_try > kernel_loops_max) break;
2950
2951 const double exec_ms = try_run (device_param, kernel_accel, kernel_loops_try, 1);
2952
2953 if (exec_ms > target_ms) break;
2954
2955 const double e = kernel_loops_try / exec_ms;
2956
2957 if (e > e_best)
2958 {
2959 kernel_loops = kernel_loops_try;
2960
2961 e_best = e;
2962 }
2963 }
2964 }
2965
2966 // final balance
2967
2968 u32 kernel_accel_best = kernel_accel;
2969 u32 kernel_loops_best = kernel_loops;
2970
2971 u32 exec_best = -1;
2972
2973 if ((kernel_accel_min < kernel_accel_max) || (kernel_loops_min < kernel_loops_max))
2974 {
2975 const double exec_ms = try_run (device_param, kernel_accel_best, kernel_loops_best, 1);
2976
2977 exec_best = exec_ms;
2978 }
2979
2980 // reset
2981
2982 if (kernel_accel_min < kernel_accel_max)
2983 {
2984 u32 kernel_accel_try = kernel_accel;
2985 u32 kernel_loops_try = kernel_loops;
2986
2987 for (int i = 0; i < 2; i++)
2988 {
2989 kernel_accel_try >>= 1;
2990 kernel_loops_try <<= 1;
2991
2992 if (kernel_accel_try < kernel_accel_min) break;
2993 if (kernel_loops_try > kernel_loops_max) break;
2994
2995 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
2996
2997 if (exec_ms < exec_best)
2998 {
2999 kernel_accel_best = kernel_accel_try;
3000 kernel_loops_best = kernel_loops_try;
3001
3002 exec_best = exec_ms;
3003 }
3004 }
3005 }
3006
3007 // reset
3008
3009 if (kernel_loops_min < kernel_loops_max)
3010 {
3011 u32 kernel_accel_try = kernel_accel;
3012 u32 kernel_loops_try = kernel_loops;
3013
3014 for (int i = 0; i < 2; i++)
3015 {
3016 kernel_accel_try <<= 1;
3017 kernel_loops_try >>= 1;
3018
3019 if (kernel_accel_try > kernel_accel_max) break;
3020 if (kernel_loops_try < kernel_loops_min) break;
3021
3022 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
3023
3024 if (exec_ms < exec_best)
3025 {
3026 kernel_accel_best = kernel_accel_try;
3027 kernel_loops_best = kernel_loops_try;
3028
3029 exec_best = exec_ms;
3030 }
3031 }
3032 }
3033
3034 // reset timer
3035
3036 device_param->exec_pos = 0;
3037
3038 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3039
3040 // store
3041
3042 kernel_accel = kernel_accel_best;
3043 kernel_loops = kernel_loops_best;
3044
3045 device_param->kernel_accel = kernel_accel;
3046 device_param->kernel_loops = kernel_loops;
3047
3048 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3049
3050 device_param->kernel_power = kernel_power;
3051
3052 #ifdef DEBUG
3053
3054 if (data.quiet == 0)
3055 {
3056 clear_prompt ();
3057
3058 log_info ("Device #%u: autotuned kernel-accel to %u\n"
3059 "Device #%u: autotuned kernel-loops to %u\n",
3060 device_param->device_id + 1,
3061 kernel_accel,
3062 device_param->device_id + 1,
3063 kernel_loops);
3064
3065 fprintf (stdout, "%s", PROMPT);
3066 fflush (stdout);
3067 }
3068
3069 #endif
3070 }
3071
3072 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3073 {
3074 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3075
3076 // init speed timer
3077
3078 uint speed_pos = device_param->speed_pos;
3079
3080 #ifdef _POSIX
3081 if (device_param->timer_speed.tv_sec == 0)
3082 {
3083 hc_timer_set (&device_param->timer_speed);
3084 }
3085 #endif
3086
3087 #ifdef _WIN
3088 if (device_param->timer_speed.QuadPart == 0)
3089 {
3090 hc_timer_set (&device_param->timer_speed);
3091 }
3092 #endif
3093
3094 // find higest password length, this is for optimization stuff
3095
3096 uint highest_pw_len = 0;
3097
3098 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3099 {
3100 }
3101 else if (data.attack_kern == ATTACK_KERN_COMBI)
3102 {
3103 }
3104 else if (data.attack_kern == ATTACK_KERN_BF)
3105 {
3106 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3107 + device_param->kernel_params_mp_l_buf32[5];
3108 }
3109
3110 // iteration type
3111
3112 uint innerloop_step = 0;
3113 uint innerloop_cnt = 0;
3114
3115 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3116 else innerloop_step = 1;
3117
3118 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3119 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3120 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3121
3122 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3123
3124 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3125 {
3126 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3127
3128 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3129
3130 if (data.devices_status == STATUS_CRACKED) break;
3131 if (data.devices_status == STATUS_ABORTED) break;
3132 if (data.devices_status == STATUS_QUIT) break;
3133 if (data.devices_status == STATUS_BYPASS) break;
3134
3135 salt_t *salt_buf = &data.salts_buf[salt_pos];
3136
3137 device_param->kernel_params_buf32[24] = salt_pos;
3138 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3139 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3140
3141 FILE *combs_fp = device_param->combs_fp;
3142
3143 if (data.attack_mode == ATTACK_MODE_COMBI)
3144 {
3145 rewind (combs_fp);
3146 }
3147
3148 // innerloops
3149
3150 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3151 {
3152 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3153
3154 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3155
3156 if (data.devices_status == STATUS_CRACKED) break;
3157 if (data.devices_status == STATUS_ABORTED) break;
3158 if (data.devices_status == STATUS_QUIT) break;
3159 if (data.devices_status == STATUS_BYPASS) break;
3160
3161 uint innerloop_left = innerloop_cnt - innerloop_pos;
3162
3163 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3164
3165 device_param->innerloop_pos = innerloop_pos;
3166 device_param->innerloop_left = innerloop_left;
3167
3168 device_param->kernel_params_buf32[27] = innerloop_left;
3169
3170 // i think we can get rid of this
3171 if (innerloop_left == 0)
3172 {
3173 puts ("bug, how should this happen????\n");
3174
3175 continue;
3176 }
3177
3178 if (data.salts_shown[salt_pos] == 1)
3179 {
3180 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3181
3182 continue;
3183 }
3184
3185 // initialize amplifiers
3186
3187 if (data.attack_mode == ATTACK_MODE_COMBI)
3188 {
3189 uint i = 0;
3190
3191 while (i < innerloop_left)
3192 {
3193 if (feof (combs_fp)) break;
3194
3195 int line_len = fgetl (combs_fp, line_buf);
3196
3197 if (line_len >= PW_MAX1) continue;
3198
3199 line_len = convert_from_hex (line_buf, line_len);
3200
3201 char *line_buf_new = line_buf;
3202
3203 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3204 {
3205 char rule_buf_out[BLOCK_SIZE] = { 0 };
3206
3207 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3208
3209 if (rule_len_out < 0)
3210 {
3211 data.words_progress_rejected[salt_pos] += pws_cnt;
3212
3213 continue;
3214 }
3215
3216 line_len = rule_len_out;
3217
3218 line_buf_new = rule_buf_out;
3219 }
3220
3221 line_len = MIN (line_len, PW_DICTMAX);
3222
3223 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3224
3225 memcpy (ptr, line_buf_new, line_len);
3226
3227 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3228
3229 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3230 {
3231 uppercase (ptr, line_len);
3232 }
3233
3234 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3235 {
3236 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3237 {
3238 ptr[line_len] = 0x80;
3239 }
3240
3241 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3242 {
3243 ptr[line_len] = 0x01;
3244 }
3245 }
3246
3247 device_param->combs_buf[i].pw_len = line_len;
3248
3249 i++;
3250 }
3251
3252 for (uint j = i; j < innerloop_left; j++)
3253 {
3254 device_param->combs_buf[j].i[0] = 0;
3255 device_param->combs_buf[j].i[1] = 0;
3256 device_param->combs_buf[j].i[2] = 0;
3257 device_param->combs_buf[j].i[3] = 0;
3258 device_param->combs_buf[j].i[4] = 0;
3259 device_param->combs_buf[j].i[5] = 0;
3260 device_param->combs_buf[j].i[6] = 0;
3261 device_param->combs_buf[j].i[7] = 0;
3262
3263 device_param->combs_buf[j].pw_len = 0;
3264 }
3265
3266 innerloop_left = i;
3267 }
3268 else if (data.attack_mode == ATTACK_MODE_BF)
3269 {
3270 u64 off = innerloop_pos;
3271
3272 device_param->kernel_params_mp_r_buf64[3] = off;
3273
3274 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3275 }
3276 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3277 {
3278 u64 off = innerloop_pos;
3279
3280 device_param->kernel_params_mp_buf64[3] = off;
3281
3282 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3283 }
3284 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3285 {
3286 u64 off = innerloop_pos;
3287
3288 device_param->kernel_params_mp_buf64[3] = off;
3289
3290 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3291 }
3292
3293 // copy amplifiers
3294
3295 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3296 {
3297 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);
3298 }
3299 else if (data.attack_mode == ATTACK_MODE_COMBI)
3300 {
3301 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);
3302 }
3303 else if (data.attack_mode == ATTACK_MODE_BF)
3304 {
3305 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);
3306 }
3307 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3308 {
3309 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);
3310 }
3311 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3312 {
3313 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);
3314 }
3315
3316 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3317
3318 if (data.benchmark == 1)
3319 {
3320 for (u32 i = 0; i < data.benchmark_repeats; i++)
3321 {
3322 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
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 if (data.benchmark == 1)
3349 {
3350 perf_sum_all = (perf_sum_all * data.benchmark_repeats) + perf_sum_all;
3351 }
3352
3353 hc_thread_mutex_lock (mux_counter);
3354
3355 data.words_progress_done[salt_pos] += perf_sum_all;
3356
3357 hc_thread_mutex_unlock (mux_counter);
3358
3359 /**
3360 * speed
3361 */
3362
3363 float speed_ms;
3364
3365 hc_timer_get (device_param->timer_speed, speed_ms);
3366
3367 hc_timer_set (&device_param->timer_speed);
3368
3369 hc_thread_mutex_lock (mux_display);
3370
3371 device_param->speed_cnt[speed_pos] = perf_sum_all;
3372
3373 device_param->speed_ms[speed_pos] = speed_ms;
3374
3375 device_param->speed_rec[speed_pos] = device_param->timer_speed;
3376
3377 hc_thread_mutex_unlock (mux_display);
3378
3379 speed_pos++;
3380
3381 if (speed_pos == SPEED_CACHE)
3382 {
3383 speed_pos = 0;
3384 }
3385
3386 /**
3387 * benchmark
3388 */
3389
3390 if (data.benchmark == 1) break;
3391 }
3392 }
3393
3394 device_param->speed_pos = speed_pos;
3395
3396 myfree (line_buf);
3397 }
3398
3399 static void load_segment (wl_data_t *wl_data, FILE *fd)
3400 {
3401 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3402
3403 wl_data->pos = 0;
3404
3405 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3406
3407 wl_data->buf[wl_data->cnt] = 0;
3408
3409 if (wl_data->cnt == 0) return;
3410
3411 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3412
3413 while (!feof (fd))
3414 {
3415 if (wl_data->cnt == wl_data->avail)
3416 {
3417 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3418
3419 wl_data->avail += wl_data->incr;
3420 }
3421
3422 const int c = fgetc (fd);
3423
3424 if (c == EOF) break;
3425
3426 wl_data->buf[wl_data->cnt] = (char) c;
3427
3428 wl_data->cnt++;
3429
3430 if (c == '\n') break;
3431 }
3432
3433 // ensure stream ends with a newline
3434
3435 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3436 {
3437 wl_data->cnt++;
3438
3439 wl_data->buf[wl_data->cnt - 1] = '\n';
3440 }
3441
3442 return;
3443 }
3444
3445 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3446 {
3447 char *ptr = buf;
3448
3449 for (u32 i = 0; i < sz; i++, ptr++)
3450 {
3451 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3452
3453 if (i == 7)
3454 {
3455 *off = i;
3456 *len = i;
3457
3458 return;
3459 }
3460
3461 if (*ptr != '\n') continue;
3462
3463 *off = i + 1;
3464
3465 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3466
3467 *len = i;
3468
3469 return;
3470 }
3471
3472 *off = sz;
3473 *len = sz;
3474 }
3475
3476 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3477 {
3478 char *ptr = buf;
3479
3480 for (u32 i = 0; i < sz; i++, ptr++)
3481 {
3482 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3483
3484 if (*ptr != '\n') continue;
3485
3486 *off = i + 1;
3487
3488 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3489
3490 *len = i;
3491
3492 return;
3493 }
3494
3495 *off = sz;
3496 *len = sz;
3497 }
3498
3499 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3500 {
3501 char *ptr = buf;
3502
3503 for (u32 i = 0; i < sz; i++, ptr++)
3504 {
3505 if (*ptr != '\n') continue;
3506
3507 *off = i + 1;
3508
3509 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3510
3511 *len = i;
3512
3513 return;
3514 }
3515
3516 *off = sz;
3517 *len = sz;
3518 }
3519
3520 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3521 {
3522 while (wl_data->pos < wl_data->cnt)
3523 {
3524 uint off;
3525 uint len;
3526
3527 char *ptr = wl_data->buf + wl_data->pos;
3528
3529 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3530
3531 wl_data->pos += off;
3532
3533 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3534 {
3535 char rule_buf_out[BLOCK_SIZE] = { 0 };
3536
3537 int rule_len_out = -1;
3538
3539 if (len < BLOCK_SIZE)
3540 {
3541 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3542 }
3543
3544 if (rule_len_out < 0)
3545 {
3546 continue;
3547 }
3548
3549 if (rule_len_out > PW_MAX)
3550 {
3551 continue;
3552 }
3553 }
3554 else
3555 {
3556 if (len > PW_MAX)
3557 {
3558 continue;
3559 }
3560 }
3561
3562 *out_buf = ptr;
3563 *out_len = len;
3564
3565 return;
3566 }
3567
3568 if (feof (fd))
3569 {
3570 fprintf (stderr, "BUG feof()!!\n");
3571
3572 return;
3573 }
3574
3575 load_segment (wl_data, fd);
3576
3577 get_next_word (wl_data, fd, out_buf, out_len);
3578 }
3579
3580 #ifdef _POSIX
3581 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3582 #endif
3583
3584 #ifdef _WIN
3585 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3586 #endif
3587 {
3588 hc_signal (NULL);
3589
3590 dictstat_t d;
3591
3592 d.cnt = 0;
3593
3594 #ifdef _POSIX
3595 fstat (fileno (fd), &d.stat);
3596 #endif
3597
3598 #ifdef _WIN
3599 _fstat64 (fileno (fd), &d.stat);
3600 #endif
3601
3602 d.stat.st_mode = 0;
3603 d.stat.st_nlink = 0;
3604 d.stat.st_uid = 0;
3605 d.stat.st_gid = 0;
3606 d.stat.st_rdev = 0;
3607 d.stat.st_atime = 0;
3608
3609 #ifdef _POSIX
3610 d.stat.st_blksize = 0;
3611 d.stat.st_blocks = 0;
3612 #endif
3613
3614 if (d.stat.st_size == 0) return 0;
3615
3616 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3617
3618 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3619 {
3620 if (d_cache)
3621 {
3622 u64 cnt = d_cache->cnt;
3623
3624 u64 keyspace = cnt;
3625
3626 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3627 {
3628 keyspace *= data.kernel_rules_cnt;
3629 }
3630 else if (data.attack_kern == ATTACK_KERN_COMBI)
3631 {
3632 keyspace *= data.combs_cnt;
3633 }
3634
3635 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);
3636 if (data.quiet == 0) log_info ("");
3637
3638 hc_signal (sigHandler_default);
3639
3640 return (keyspace);
3641 }
3642 }
3643
3644 time_t now = 0;
3645 time_t prev = 0;
3646
3647 u64 comp = 0;
3648 u64 cnt = 0;
3649 u64 cnt2 = 0;
3650
3651 while (!feof (fd))
3652 {
3653 load_segment (wl_data, fd);
3654
3655 comp += wl_data->cnt;
3656
3657 u32 i = 0;
3658
3659 while (i < wl_data->cnt)
3660 {
3661 u32 len;
3662 u32 off;
3663
3664 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3665
3666 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3667 {
3668 char rule_buf_out[BLOCK_SIZE] = { 0 };
3669
3670 int rule_len_out = -1;
3671
3672 if (len < BLOCK_SIZE)
3673 {
3674 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3675 }
3676
3677 if (rule_len_out < 0)
3678 {
3679 len = PW_MAX1;
3680 }
3681 else
3682 {
3683 len = rule_len_out;
3684 }
3685 }
3686
3687 if (len < PW_MAX1)
3688 {
3689 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3690 {
3691 cnt += data.kernel_rules_cnt;
3692 }
3693 else if (data.attack_kern == ATTACK_KERN_COMBI)
3694 {
3695 cnt += data.combs_cnt;
3696 }
3697
3698 d.cnt++;
3699 }
3700
3701 i += off;
3702
3703 cnt2++;
3704 }
3705
3706 time (&now);
3707
3708 if ((now - prev) == 0) continue;
3709
3710 float percent = (float) comp / (float) d.stat.st_size;
3711
3712 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);
3713
3714 time (&prev);
3715 }
3716
3717 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);
3718 if (data.quiet == 0) log_info ("");
3719
3720 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3721
3722 hc_signal (sigHandler_default);
3723
3724 return (cnt);
3725 }
3726
3727 static void *thread_monitor (void *p)
3728 {
3729 uint runtime_check = 0;
3730 uint remove_check = 0;
3731 uint status_check = 0;
3732 uint restore_check = 0;
3733
3734 uint restore_left = data.restore_timer;
3735 uint remove_left = data.remove_timer;
3736 uint status_left = data.status_timer;
3737
3738 #ifdef HAVE_HWMON
3739 uint hwmon_check = 0;
3740
3741 // these variables are mainly used for fan control (AMD only)
3742
3743 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3744
3745 // temperature controller "loopback" values
3746
3747 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3748 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3749
3750 #ifdef HAVE_ADL
3751 int temp_threshold = 1; // degrees celcius
3752
3753 int fan_speed_min = 15; // in percentage
3754 int fan_speed_max = 100;
3755 #endif // HAVE_ADL
3756
3757 time_t last_temp_check_time;
3758 #endif // HAVE_HWMON
3759
3760 uint sleep_time = 1;
3761
3762 if (data.runtime)
3763 {
3764 runtime_check = 1;
3765 }
3766
3767 if (data.restore_timer)
3768 {
3769 restore_check = 1;
3770 }
3771
3772 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3773 {
3774 remove_check = 1;
3775 }
3776
3777 if (data.status == 1)
3778 {
3779 status_check = 1;
3780 }
3781
3782 #ifdef HAVE_HWMON
3783 if (data.gpu_temp_disable == 0)
3784 {
3785 time (&last_temp_check_time);
3786
3787 hwmon_check = 1;
3788 }
3789 #endif
3790
3791 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3792 {
3793 #ifdef HAVE_HWMON
3794 if (hwmon_check == 0)
3795 #endif
3796 return (p);
3797 }
3798
3799 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3800 {
3801 hc_sleep (sleep_time);
3802
3803 if (data.devices_status != STATUS_RUNNING) continue;
3804
3805 #ifdef HAVE_HWMON
3806 if (hwmon_check == 1)
3807 {
3808 hc_thread_mutex_lock (mux_adl);
3809
3810 time_t temp_check_time;
3811
3812 time (&temp_check_time);
3813
3814 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3815
3816 if (Ta == 0) Ta = 1;
3817
3818 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3819 {
3820 hc_device_param_t *device_param = &data.devices_param[device_id];
3821
3822 if (device_param->skipped) continue;
3823
3824 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3825
3826 const int temperature = hm_get_temperature_with_device_id (device_id);
3827
3828 if (temperature > (int) data.gpu_temp_abort)
3829 {
3830 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3831
3832 if (data.devices_status != STATUS_QUIT) myabort ();
3833
3834 break;
3835 }
3836
3837 #ifdef HAVE_ADL
3838 const int gpu_temp_retain = data.gpu_temp_retain;
3839
3840 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3841 {
3842 if (data.hm_device[device_id].fan_supported == 1)
3843 {
3844 int temp_cur = temperature;
3845
3846 int temp_diff_new = gpu_temp_retain - temp_cur;
3847
3848 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3849
3850 // calculate Ta value (time difference in seconds between the last check and this check)
3851
3852 last_temp_check_time = temp_check_time;
3853
3854 float Kp = 1.8;
3855 float Ki = 0.005;
3856 float Kd = 6;
3857
3858 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3859
3860 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);
3861
3862 if (abs (fan_diff_required) >= temp_threshold)
3863 {
3864 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3865
3866 int fan_speed_level = fan_speed_cur;
3867
3868 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3869
3870 int fan_speed_new = fan_speed_level - fan_diff_required;
3871
3872 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3873 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3874
3875 if (fan_speed_new != fan_speed_cur)
3876 {
3877 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3878 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3879
3880 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3881 {
3882 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3883
3884 fan_speed_chgd[device_id] = 1;
3885 }
3886
3887 temp_diff_old[device_id] = temp_diff_new;
3888 }
3889 }
3890 }
3891 }
3892 #endif // HAVE_ADL
3893 }
3894
3895 hc_thread_mutex_unlock (mux_adl);
3896 }
3897 #endif // HAVE_HWMON
3898
3899 if (restore_check == 1)
3900 {
3901 restore_left--;
3902
3903 if (restore_left == 0)
3904 {
3905 if (data.restore_disable == 0) cycle_restore ();
3906
3907 restore_left = data.restore_timer;
3908 }
3909 }
3910
3911 if ((runtime_check == 1) && (data.runtime_start > 0))
3912 {
3913 time_t runtime_cur;
3914
3915 time (&runtime_cur);
3916
3917 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3918
3919 if (runtime_left <= 0)
3920 {
3921 if (data.benchmark == 0)
3922 {
3923 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3924 }
3925
3926 if (data.devices_status != STATUS_QUIT) myabort ();
3927 }
3928 }
3929
3930 if (remove_check == 1)
3931 {
3932 remove_left--;
3933
3934 if (remove_left == 0)
3935 {
3936 if (data.digests_saved != data.digests_done)
3937 {
3938 data.digests_saved = data.digests_done;
3939
3940 save_hash ();
3941 }
3942
3943 remove_left = data.remove_timer;
3944 }
3945 }
3946
3947 if (status_check == 1)
3948 {
3949 status_left--;
3950
3951 if (status_left == 0)
3952 {
3953 hc_thread_mutex_lock (mux_display);
3954
3955 if (data.quiet == 0) clear_prompt ();
3956
3957 if (data.quiet == 0) log_info ("");
3958
3959 status_display ();
3960
3961 if (data.quiet == 0) log_info ("");
3962
3963 hc_thread_mutex_unlock (mux_display);
3964
3965 status_left = data.status_timer;
3966 }
3967 }
3968 }
3969
3970 #ifdef HAVE_HWMON
3971 myfree (fan_speed_chgd);
3972
3973 myfree (temp_diff_old);
3974 myfree (temp_diff_sum);
3975 #endif
3976
3977 p = NULL;
3978
3979 return (p);
3980 }
3981
3982 static void *thread_outfile_remove (void *p)
3983 {
3984 // some hash-dependent constants
3985 char *outfile_dir = data.outfile_check_directory;
3986 uint dgst_size = data.dgst_size;
3987 uint isSalted = data.isSalted;
3988 uint esalt_size = data.esalt_size;
3989 uint hash_mode = data.hash_mode;
3990
3991 uint outfile_check_timer = data.outfile_check_timer;
3992
3993 char separator = data.separator;
3994
3995 // some hash-dependent functions
3996 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3997 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3998
3999 // buffers
4000 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4001
4002 hash_buf.digest = mymalloc (dgst_size);
4003
4004 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4005
4006 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4007
4008 uint digest_buf[64] = { 0 };
4009
4010 outfile_data_t *out_info = NULL;
4011
4012 char **out_files = NULL;
4013
4014 time_t folder_mtime = 0;
4015
4016 int out_cnt = 0;
4017
4018 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4019
4020 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4021 {
4022 hc_sleep (1);
4023
4024 if (data.devices_status != STATUS_RUNNING) continue;
4025
4026 check_left--;
4027
4028 if (check_left == 0)
4029 {
4030 struct stat outfile_check_stat;
4031
4032 if (stat (outfile_dir, &outfile_check_stat) == 0)
4033 {
4034 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4035
4036 if (is_dir == 1)
4037 {
4038 if (outfile_check_stat.st_mtime > folder_mtime)
4039 {
4040 char **out_files_new = scan_directory (outfile_dir);
4041
4042 int out_cnt_new = count_dictionaries (out_files_new);
4043
4044 outfile_data_t *out_info_new = NULL;
4045
4046 if (out_cnt_new > 0)
4047 {
4048 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4049
4050 for (int i = 0; i < out_cnt_new; i++)
4051 {
4052 out_info_new[i].file_name = out_files_new[i];
4053
4054 // check if there are files that we have seen/checked before (and not changed)
4055
4056 for (int j = 0; j < out_cnt; j++)
4057 {
4058 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4059 {
4060 struct stat outfile_stat;
4061
4062 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4063 {
4064 if (outfile_stat.st_ctime == out_info[j].ctime)
4065 {
4066 out_info_new[i].ctime = out_info[j].ctime;
4067 out_info_new[i].seek = out_info[j].seek;
4068 }
4069 }
4070 }
4071 }
4072 }
4073 }
4074
4075 local_free (out_info);
4076 local_free (out_files);
4077
4078 out_files = out_files_new;
4079 out_cnt = out_cnt_new;
4080 out_info = out_info_new;
4081
4082 folder_mtime = outfile_check_stat.st_mtime;
4083 }
4084
4085 for (int j = 0; j < out_cnt; j++)
4086 {
4087 FILE *fp = fopen (out_info[j].file_name, "rb");
4088
4089 if (fp != NULL)
4090 {
4091 //hc_thread_mutex_lock (mux_display);
4092
4093 #ifdef _POSIX
4094 struct stat outfile_stat;
4095
4096 fstat (fileno (fp), &outfile_stat);
4097 #endif
4098
4099 #ifdef _WIN
4100 struct stat64 outfile_stat;
4101
4102 _fstat64 (fileno (fp), &outfile_stat);
4103 #endif
4104
4105 if (outfile_stat.st_ctime > out_info[j].ctime)
4106 {
4107 out_info[j].ctime = outfile_stat.st_ctime;
4108 out_info[j].seek = 0;
4109 }
4110
4111 fseek (fp, out_info[j].seek, SEEK_SET);
4112
4113 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4114
4115 while (!feof (fp))
4116 {
4117 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4118
4119 if (ptr == NULL) break;
4120
4121 int line_len = strlen (line_buf);
4122
4123 if (line_len <= 0) continue;
4124
4125 int iter = MAX_CUT_TRIES;
4126
4127 for (uint i = line_len - 1; i && iter; i--, line_len--)
4128 {
4129 if (line_buf[i] != separator) continue;
4130
4131 int parser_status = PARSER_OK;
4132
4133 if ((hash_mode != 2500) && (hash_mode != 6800))
4134 {
4135 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4136 }
4137
4138 uint found = 0;
4139
4140 if (parser_status == PARSER_OK)
4141 {
4142 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4143 {
4144 if (data.salts_shown[salt_pos] == 1) continue;
4145
4146 salt_t *salt_buf = &data.salts_buf[salt_pos];
4147
4148 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4149 {
4150 uint idx = salt_buf->digests_offset + digest_pos;
4151
4152 if (data.digests_shown[idx] == 1) continue;
4153
4154 uint cracked = 0;
4155
4156 if (hash_mode == 6800)
4157 {
4158 if (i == salt_buf->salt_len)
4159 {
4160 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4161 }
4162 }
4163 else if (hash_mode == 2500)
4164 {
4165 // BSSID : MAC1 : MAC2 (:plain)
4166 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4167 {
4168 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4169
4170 if (!cracked) continue;
4171
4172 // now compare MAC1 and MAC2 too, since we have this additional info
4173 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4174 char *mac2_pos = mac1_pos + 12 + 1;
4175
4176 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4177 wpa_t *wpa = &wpas[salt_pos];
4178
4179 uint pke[25] = { 0 };
4180
4181 char *pke_ptr = (char *) pke;
4182
4183 for (uint i = 0; i < 25; i++)
4184 {
4185 pke[i] = byte_swap_32 (wpa->pke[i]);
4186 }
4187
4188 u8 mac1[6] = { 0 };
4189 u8 mac2[6] = { 0 };
4190
4191 memcpy (mac1, pke_ptr + 23, 6);
4192 memcpy (mac2, pke_ptr + 29, 6);
4193
4194 // compare hex string(s) vs binary MAC address(es)
4195
4196 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4197 {
4198 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4199 {
4200 cracked = 0;
4201 break;
4202 }
4203 }
4204
4205 // early skip ;)
4206 if (!cracked) continue;
4207
4208 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4209 {
4210 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4211 {
4212 cracked = 0;
4213 break;
4214 }
4215 }
4216 }
4217 }
4218 else
4219 {
4220 char *digests_buf_ptr = (char *) data.digests_buf;
4221
4222 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4223
4224 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4225 }
4226
4227 if (cracked == 1)
4228 {
4229 found = 1;
4230
4231 data.digests_shown[idx] = 1;
4232
4233 data.digests_done++;
4234
4235 salt_buf->digests_done++;
4236
4237 if (salt_buf->digests_done == salt_buf->digests_cnt)
4238 {
4239 data.salts_shown[salt_pos] = 1;
4240
4241 data.salts_done++;
4242
4243 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4244 }
4245 }
4246 }
4247
4248 if (data.devices_status == STATUS_CRACKED) break;
4249 }
4250 }
4251
4252 if (found) break;
4253
4254 if (data.devices_status == STATUS_CRACKED) break;
4255
4256 iter--;
4257 }
4258
4259 if (data.devices_status == STATUS_CRACKED) break;
4260 }
4261
4262 myfree (line_buf);
4263
4264 out_info[j].seek = ftell (fp);
4265
4266 //hc_thread_mutex_unlock (mux_display);
4267
4268 fclose (fp);
4269 }
4270 }
4271 }
4272 }
4273
4274 check_left = outfile_check_timer;
4275 }
4276 }
4277
4278 if (esalt_size) local_free (hash_buf.esalt);
4279
4280 if (isSalted) local_free (hash_buf.salt);
4281
4282 local_free (hash_buf.digest);
4283
4284 local_free (out_info);
4285
4286 local_free (out_files);
4287
4288 p = NULL;
4289
4290 return (p);
4291 }
4292
4293 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4294 {
4295 if (device_param->pws_cnt < device_param->kernel_power)
4296 {
4297 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4298
4299 u8 *ptr = (u8 *) pw->i;
4300
4301 memcpy (ptr, pw_buf, pw_len);
4302
4303 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4304
4305 pw->pw_len = pw_len;
4306
4307 device_param->pws_cnt++;
4308 }
4309 else
4310 {
4311 fprintf (stderr, "BUG pw_add()!!\n");
4312
4313 return;
4314 }
4315 }
4316
4317 static uint get_work (hc_device_param_t *device_param, const u64 max, const bool allow_div)
4318 {
4319 hc_thread_mutex_lock (mux_dispatcher);
4320
4321 const u64 words_cur = data.words_cur;
4322 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4323
4324 device_param->words_off = words_cur;
4325
4326 const u64 words_left = words_base - words_cur;
4327
4328 if (allow_div)
4329 {
4330 if (data.kernel_power_all > words_left)
4331 {
4332 if (data.kernel_power_div == 0)
4333 {
4334 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4335 }
4336 }
4337
4338 if (data.kernel_power_div)
4339 {
4340 if (device_param->kernel_power == device_param->kernel_power_user)
4341 {
4342 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4343
4344 if (kernel_power_new < device_param->kernel_power)
4345 {
4346 device_param->kernel_power = kernel_power_new;
4347 }
4348 }
4349 }
4350 }
4351
4352 const uint kernel_power = device_param->kernel_power;
4353
4354 uint work = MIN (words_left, kernel_power);
4355
4356 work = MIN (work, max);
4357
4358 data.words_cur += work;
4359
4360 hc_thread_mutex_unlock (mux_dispatcher);
4361
4362 return work;
4363 }
4364
4365 static void *thread_calc_stdin (void *p)
4366 {
4367 hc_device_param_t *device_param = (hc_device_param_t *) p;
4368
4369 if (device_param->skipped) return NULL;
4370
4371 autotune (device_param);
4372
4373 char *buf = (char *) mymalloc (HCBUFSIZ);
4374
4375 const uint attack_kern = data.attack_kern;
4376
4377 const uint kernel_power = device_param->kernel_power;
4378
4379 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4380 {
4381 hc_thread_mutex_lock (mux_dispatcher);
4382
4383 if (feof (stdin) != 0)
4384 {
4385 hc_thread_mutex_unlock (mux_dispatcher);
4386
4387 break;
4388 }
4389
4390 uint words_cur = 0;
4391
4392 while (words_cur < kernel_power)
4393 {
4394 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4395
4396 if (line_buf == NULL) break;
4397
4398 uint line_len = in_superchop (line_buf);
4399
4400 line_len = convert_from_hex (line_buf, line_len);
4401
4402 // post-process rule engine
4403
4404 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4405 {
4406 char rule_buf_out[BLOCK_SIZE] = { 0 };
4407
4408 int rule_len_out = -1;
4409
4410 if (line_len < BLOCK_SIZE)
4411 {
4412 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4413 }
4414
4415 if (rule_len_out < 0) continue;
4416
4417 line_buf = rule_buf_out;
4418 line_len = rule_len_out;
4419 }
4420
4421 if (line_len > PW_MAX)
4422 {
4423 continue;
4424 }
4425
4426 if (attack_kern == ATTACK_KERN_STRAIGHT)
4427 {
4428 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4429 {
4430 hc_thread_mutex_lock (mux_counter);
4431
4432 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4433 {
4434 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4435 }
4436
4437 hc_thread_mutex_unlock (mux_counter);
4438
4439 continue;
4440 }
4441 }
4442 else if (attack_kern == ATTACK_KERN_COMBI)
4443 {
4444 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4445 // since we still need to combine the plains
4446
4447 if (line_len > data.pw_max)
4448 {
4449 hc_thread_mutex_lock (mux_counter);
4450
4451 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4452 {
4453 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4454 }
4455
4456 hc_thread_mutex_unlock (mux_counter);
4457
4458 continue;
4459 }
4460 }
4461
4462 pw_add (device_param, (u8 *) line_buf, line_len);
4463
4464 words_cur++;
4465
4466 if (data.devices_status == STATUS_CRACKED) break;
4467 if (data.devices_status == STATUS_ABORTED) break;
4468 if (data.devices_status == STATUS_QUIT) break;
4469 if (data.devices_status == STATUS_BYPASS) break;
4470 }
4471
4472 hc_thread_mutex_unlock (mux_dispatcher);
4473
4474 if (data.devices_status == STATUS_CRACKED) break;
4475 if (data.devices_status == STATUS_ABORTED) break;
4476 if (data.devices_status == STATUS_QUIT) break;
4477 if (data.devices_status == STATUS_BYPASS) break;
4478
4479 // flush
4480
4481 const uint pws_cnt = device_param->pws_cnt;
4482
4483 if (pws_cnt)
4484 {
4485 run_copy (device_param, pws_cnt);
4486
4487 run_cracker (device_param, pws_cnt);
4488
4489 device_param->pws_cnt = 0;
4490
4491 if (attack_kern == ATTACK_KERN_STRAIGHT)
4492 {
4493 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4494 }
4495 else if (attack_kern == ATTACK_KERN_COMBI)
4496 {
4497 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4498 }
4499 }
4500 }
4501
4502 device_param->kernel_accel = 0;
4503 device_param->kernel_loops = 0;
4504
4505 myfree (buf);
4506
4507 return NULL;
4508 }
4509
4510 static void *thread_calc (void *p)
4511 {
4512 hc_device_param_t *device_param = (hc_device_param_t *) p;
4513
4514 if (device_param->skipped) return NULL;
4515
4516 autotune (device_param);
4517
4518 const uint attack_mode = data.attack_mode;
4519 const uint attack_kern = data.attack_kern;
4520
4521 if (attack_mode == ATTACK_MODE_BF)
4522 {
4523 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4524 {
4525 const uint work = get_work (device_param, -1, true);
4526
4527 if (work == 0) break;
4528
4529 const u64 words_off = device_param->words_off;
4530 const u64 words_fin = words_off + work;
4531
4532 const uint pws_cnt = work;
4533
4534 device_param->pws_cnt = pws_cnt;
4535
4536 if (pws_cnt)
4537 {
4538 run_copy (device_param, pws_cnt);
4539
4540 run_cracker (device_param, pws_cnt);
4541
4542 device_param->pws_cnt = 0;
4543
4544 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4545 }
4546
4547 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4548
4549 if (data.devices_status == STATUS_CRACKED) break;
4550 if (data.devices_status == STATUS_ABORTED) break;
4551 if (data.devices_status == STATUS_QUIT) break;
4552 if (data.devices_status == STATUS_BYPASS) break;
4553
4554 if (data.benchmark == 1) break;
4555
4556 device_param->words_done = words_fin;
4557 }
4558 }
4559 else
4560 {
4561 const uint segment_size = data.segment_size;
4562
4563 char *dictfile = data.dictfile;
4564
4565 if (attack_mode == ATTACK_MODE_COMBI)
4566 {
4567 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4568 {
4569 dictfile = data.dictfile2;
4570 }
4571 }
4572
4573 FILE *fd = fopen (dictfile, "rb");
4574
4575 if (fd == NULL)
4576 {
4577 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4578
4579 return NULL;
4580 }
4581
4582 if (attack_mode == ATTACK_MODE_COMBI)
4583 {
4584 const uint combs_mode = data.combs_mode;
4585
4586 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4587 {
4588 const char *dictfilec = data.dictfile2;
4589
4590 FILE *combs_fp = fopen (dictfilec, "rb");
4591
4592 if (combs_fp == NULL)
4593 {
4594 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4595
4596 fclose (fd);
4597
4598 return NULL;
4599 }
4600
4601 device_param->combs_fp = combs_fp;
4602 }
4603 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4604 {
4605 const char *dictfilec = data.dictfile;
4606
4607 FILE *combs_fp = fopen (dictfilec, "rb");
4608
4609 if (combs_fp == NULL)
4610 {
4611 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4612
4613 fclose (fd);
4614
4615 return NULL;
4616 }
4617
4618 device_param->combs_fp = combs_fp;
4619 }
4620 }
4621
4622 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4623
4624 wl_data->buf = (char *) mymalloc (segment_size);
4625 wl_data->avail = segment_size;
4626 wl_data->incr = segment_size;
4627 wl_data->cnt = 0;
4628 wl_data->pos = 0;
4629
4630 u64 words_cur = 0;
4631
4632 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4633 {
4634 u64 words_off = 0;
4635 u64 words_fin = 0;
4636
4637 bool allow_div = true;
4638
4639 u64 max = -1;
4640
4641 while (max)
4642 {
4643 const uint work = get_work (device_param, max, allow_div);
4644
4645 allow_div = false;
4646
4647 if (work == 0) break;
4648
4649 words_off = device_param->words_off;
4650 words_fin = words_off + work;
4651
4652 char *line_buf;
4653 uint line_len;
4654
4655 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4656
4657 max = 0;
4658
4659 for ( ; words_cur < words_fin; words_cur++)
4660 {
4661 get_next_word (wl_data, fd, &line_buf, &line_len);
4662
4663 line_len = convert_from_hex (line_buf, line_len);
4664
4665 // post-process rule engine
4666
4667 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4668 {
4669 char rule_buf_out[BLOCK_SIZE] = { 0 };
4670
4671 int rule_len_out = -1;
4672
4673 if (line_len < BLOCK_SIZE)
4674 {
4675 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4676 }
4677
4678 if (rule_len_out < 0) continue;
4679
4680 line_buf = rule_buf_out;
4681 line_len = rule_len_out;
4682 }
4683
4684 if (attack_kern == ATTACK_KERN_STRAIGHT)
4685 {
4686 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4687 {
4688 max++;
4689
4690 hc_thread_mutex_lock (mux_counter);
4691
4692 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4693 {
4694 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4695 }
4696
4697 hc_thread_mutex_unlock (mux_counter);
4698
4699 continue;
4700 }
4701 }
4702 else if (attack_kern == ATTACK_KERN_COMBI)
4703 {
4704 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4705 // since we still need to combine the plains
4706
4707 if (line_len > data.pw_max)
4708 {
4709 max++;
4710
4711 hc_thread_mutex_lock (mux_counter);
4712
4713 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4714 {
4715 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4716 }
4717
4718 hc_thread_mutex_unlock (mux_counter);
4719
4720 continue;
4721 }
4722 }
4723
4724 pw_add (device_param, (u8 *) line_buf, line_len);
4725
4726 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4727
4728 if (data.devices_status == STATUS_CRACKED) break;
4729 if (data.devices_status == STATUS_ABORTED) break;
4730 if (data.devices_status == STATUS_QUIT) break;
4731 if (data.devices_status == STATUS_BYPASS) break;
4732 }
4733
4734 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4735
4736 if (data.devices_status == STATUS_CRACKED) break;
4737 if (data.devices_status == STATUS_ABORTED) break;
4738 if (data.devices_status == STATUS_QUIT) break;
4739 if (data.devices_status == STATUS_BYPASS) break;
4740 }
4741
4742 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4743
4744 if (data.devices_status == STATUS_CRACKED) break;
4745 if (data.devices_status == STATUS_ABORTED) break;
4746 if (data.devices_status == STATUS_QUIT) break;
4747 if (data.devices_status == STATUS_BYPASS) break;
4748
4749 //
4750 // flush
4751 //
4752
4753 const uint pws_cnt = device_param->pws_cnt;
4754
4755 if (pws_cnt)
4756 {
4757 run_copy (device_param, pws_cnt);
4758
4759 run_cracker (device_param, pws_cnt);
4760
4761 device_param->pws_cnt = 0;
4762
4763 if (attack_kern == ATTACK_KERN_STRAIGHT)
4764 {
4765 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4766 }
4767 else if (attack_kern == ATTACK_KERN_COMBI)
4768 {
4769 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4770 }
4771 }
4772
4773 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4774
4775 if (data.devices_status == STATUS_CRACKED) break;
4776 if (data.devices_status == STATUS_ABORTED) break;
4777 if (data.devices_status == STATUS_QUIT) break;
4778 if (data.devices_status == STATUS_BYPASS) break;
4779
4780 if (words_fin == 0) break;
4781
4782 device_param->words_done = words_fin;
4783 }
4784
4785 if (attack_mode == ATTACK_MODE_COMBI)
4786 {
4787 fclose (device_param->combs_fp);
4788 }
4789
4790 free (wl_data->buf);
4791 free (wl_data);
4792
4793 fclose (fd);
4794 }
4795
4796 device_param->kernel_accel = 0;
4797 device_param->kernel_loops = 0;
4798
4799 return NULL;
4800 }
4801
4802 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4803 {
4804 if (!device_param)
4805 {
4806 log_error ("ERROR: %s : Invalid argument", __func__);
4807
4808 exit (-1);
4809 }
4810
4811 salt_t *salt_buf = &data.salts_buf[salt_pos];
4812
4813 device_param->kernel_params_buf32[24] = salt_pos;
4814 device_param->kernel_params_buf32[27] = 1;
4815 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4816 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4817 device_param->kernel_params_buf32[30] = 0;
4818 device_param->kernel_params_buf32[31] = 1;
4819
4820 char *dictfile_old = data.dictfile;
4821
4822 const char *weak_hash_check = "weak-hash-check";
4823
4824 data.dictfile = (char *) weak_hash_check;
4825
4826 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4827
4828 data.kernel_rules_buf[0].cmds[0] = 0;
4829
4830 /**
4831 * run the kernel
4832 */
4833
4834 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4835 {
4836 run_kernel (KERN_RUN_1, device_param, 1, false);
4837 }
4838 else
4839 {
4840 run_kernel (KERN_RUN_1, device_param, 1, false);
4841
4842 uint loop_step = 16;
4843
4844 const uint iter = salt_buf->salt_iter;
4845
4846 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4847 {
4848 uint loop_left = iter - loop_pos;
4849
4850 loop_left = MIN (loop_left, loop_step);
4851
4852 device_param->kernel_params_buf32[25] = loop_pos;
4853 device_param->kernel_params_buf32[26] = loop_left;
4854
4855 run_kernel (KERN_RUN_2, device_param, 1, false);
4856 }
4857
4858 run_kernel (KERN_RUN_3, device_param, 1, false);
4859 }
4860
4861 /**
4862 * result
4863 */
4864
4865 check_cracked (device_param, salt_pos);
4866
4867 /**
4868 * cleanup
4869 */
4870
4871 device_param->kernel_params_buf32[24] = 0;
4872 device_param->kernel_params_buf32[25] = 0;
4873 device_param->kernel_params_buf32[26] = 0;
4874 device_param->kernel_params_buf32[27] = 0;
4875 device_param->kernel_params_buf32[28] = 0;
4876 device_param->kernel_params_buf32[29] = 0;
4877 device_param->kernel_params_buf32[30] = 0;
4878 device_param->kernel_params_buf32[31] = 0;
4879
4880 data.dictfile = dictfile_old;
4881
4882 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4883 }
4884
4885 // hlfmt hashcat
4886
4887 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4888 {
4889 if (data.username == 0)
4890 {
4891 *hashbuf_pos = line_buf;
4892 *hashbuf_len = line_len;
4893 }
4894 else
4895 {
4896 char *pos = line_buf;
4897 int len = line_len;
4898
4899 for (int i = 0; i < line_len; i++, pos++, len--)
4900 {
4901 if (line_buf[i] == data.separator)
4902 {
4903 pos++;
4904
4905 len--;
4906
4907 break;
4908 }
4909 }
4910
4911 *hashbuf_pos = pos;
4912 *hashbuf_len = len;
4913 }
4914 }
4915
4916 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4917 {
4918 char *pos = NULL;
4919 int len = 0;
4920
4921 int sep_cnt = 0;
4922
4923 for (int i = 0; i < line_len; i++)
4924 {
4925 if (line_buf[i] == data.separator)
4926 {
4927 sep_cnt++;
4928
4929 continue;
4930 }
4931
4932 if (sep_cnt == 0)
4933 {
4934 if (pos == NULL) pos = line_buf + i;
4935
4936 len++;
4937 }
4938 }
4939
4940 *userbuf_pos = pos;
4941 *userbuf_len = len;
4942 }
4943
4944 // hlfmt pwdump
4945
4946 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
4947 {
4948 int sep_cnt = 0;
4949
4950 int sep2_len = 0;
4951 int sep3_len = 0;
4952
4953 for (int i = 0; i < line_len; i++)
4954 {
4955 if (line_buf[i] == ':')
4956 {
4957 sep_cnt++;
4958
4959 continue;
4960 }
4961
4962 if (sep_cnt == 2) sep2_len++;
4963 if (sep_cnt == 3) sep3_len++;
4964 }
4965
4966 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4967
4968 return 0;
4969 }
4970
4971 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4972 {
4973 char *pos = NULL;
4974 int len = 0;
4975
4976 int sep_cnt = 0;
4977
4978 for (int i = 0; i < line_len; i++)
4979 {
4980 if (line_buf[i] == ':')
4981 {
4982 sep_cnt++;
4983
4984 continue;
4985 }
4986
4987 if (data.hash_mode == 1000)
4988 {
4989 if (sep_cnt == 3)
4990 {
4991 if (pos == NULL) pos = line_buf + i;
4992
4993 len++;
4994 }
4995 }
4996 else if (data.hash_mode == 3000)
4997 {
4998 if (sep_cnt == 2)
4999 {
5000 if (pos == NULL) pos = line_buf + i;
5001
5002 len++;
5003 }
5004 }
5005 }
5006
5007 *hashbuf_pos = pos;
5008 *hashbuf_len = len;
5009 }
5010
5011 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5012 {
5013 char *pos = NULL;
5014 int len = 0;
5015
5016 int sep_cnt = 0;
5017
5018 for (int i = 0; i < line_len; i++)
5019 {
5020 if (line_buf[i] == ':')
5021 {
5022 sep_cnt++;
5023
5024 continue;
5025 }
5026
5027 if (sep_cnt == 0)
5028 {
5029 if (pos == NULL) pos = line_buf + i;
5030
5031 len++;
5032 }
5033 }
5034
5035 *userbuf_pos = pos;
5036 *userbuf_len = len;
5037 }
5038
5039 // hlfmt passwd
5040
5041 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5042 {
5043 int sep_cnt = 0;
5044
5045 char sep5_first = 0;
5046 char sep6_first = 0;
5047
5048 for (int i = 0; i < line_len; i++)
5049 {
5050 if (line_buf[i] == ':')
5051 {
5052 sep_cnt++;
5053
5054 continue;
5055 }
5056
5057 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5058 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5059 }
5060
5061 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5062
5063 return 0;
5064 }
5065
5066 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5067 {
5068 char *pos = NULL;
5069 int len = 0;
5070
5071 int sep_cnt = 0;
5072
5073 for (int i = 0; i < line_len; i++)
5074 {
5075 if (line_buf[i] == ':')
5076 {
5077 sep_cnt++;
5078
5079 continue;
5080 }
5081
5082 if (sep_cnt == 1)
5083 {
5084 if (pos == NULL) pos = line_buf + i;
5085
5086 len++;
5087 }
5088 }
5089
5090 *hashbuf_pos = pos;
5091 *hashbuf_len = len;
5092 }
5093
5094 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5095 {
5096 char *pos = NULL;
5097 int len = 0;
5098
5099 int sep_cnt = 0;
5100
5101 for (int i = 0; i < line_len; i++)
5102 {
5103 if (line_buf[i] == ':')
5104 {
5105 sep_cnt++;
5106
5107 continue;
5108 }
5109
5110 if (sep_cnt == 0)
5111 {
5112 if (pos == NULL) pos = line_buf + i;
5113
5114 len++;
5115 }
5116 }
5117
5118 *userbuf_pos = pos;
5119 *userbuf_len = len;
5120 }
5121
5122 // hlfmt shadow
5123
5124 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5125 {
5126 int sep_cnt = 0;
5127
5128 for (int i = 0; i < line_len; i++)
5129 {
5130 if (line_buf[i] == ':') sep_cnt++;
5131 }
5132
5133 if (sep_cnt == 8) return 1;
5134
5135 return 0;
5136 }
5137
5138 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5139 {
5140 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5141 }
5142
5143 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5144 {
5145 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5146 }
5147
5148 // hlfmt main
5149
5150 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5151 {
5152 switch (hashfile_format)
5153 {
5154 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5155 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5156 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5157 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5158 }
5159 }
5160
5161 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5162 {
5163 switch (hashfile_format)
5164 {
5165 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5166 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5167 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5168 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5169 }
5170 }
5171
5172 char *strhlfmt (const uint hashfile_format)
5173 {
5174 switch (hashfile_format)
5175 {
5176 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5177 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5178 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5179 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5180 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5181 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5182 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5183 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5184 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5185 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5186 }
5187
5188 return ((char *) "Unknown");
5189 }
5190
5191 static uint hlfmt_detect (FILE *fp, uint max_check)
5192 {
5193 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5194
5195 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5196 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5197
5198 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5199
5200 uint num_check = 0;
5201
5202 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5203
5204 while (!feof (fp))
5205 {
5206 int line_len = fgetl (fp, line_buf);
5207
5208 if (line_len == 0) continue;
5209
5210 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5211 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5212 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5213
5214 if (num_check == max_check) break;
5215
5216 num_check++;
5217 }
5218
5219 myfree (line_buf);
5220
5221 uint hashlist_format = HLFMT_HASHCAT;
5222
5223 for (int i = 1; i < HLFMTS_CNT; i++)
5224 {
5225 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5226
5227 hashlist_format = i;
5228 }
5229
5230 free (formats_cnt);
5231
5232 return hashlist_format;
5233 }
5234
5235 /**
5236 * some further helper function
5237 */
5238
5239 // wrapper around mymalloc for ADL
5240
5241 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5242 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5243 {
5244 return mymalloc (iSize);
5245 }
5246 #endif
5247
5248 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)
5249 {
5250 u64 collisions = 0;
5251
5252 const uint dgst_pos0 = data.dgst_pos0;
5253 const uint dgst_pos1 = data.dgst_pos1;
5254 const uint dgst_pos2 = data.dgst_pos2;
5255 const uint dgst_pos3 = data.dgst_pos3;
5256
5257 memset (bitmap_a, 0, bitmap_size);
5258 memset (bitmap_b, 0, bitmap_size);
5259 memset (bitmap_c, 0, bitmap_size);
5260 memset (bitmap_d, 0, bitmap_size);
5261
5262 for (uint i = 0; i < digests_cnt; i++)
5263 {
5264 uint *digest_ptr = (uint *) digests_buf_ptr;
5265
5266 digests_buf_ptr += dgst_size;
5267
5268 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5269 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5270 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5271 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5272
5273 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5274 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5275 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5276 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5277
5278 if (bitmap_a[idx0] & val0) collisions++;
5279 if (bitmap_b[idx1] & val1) collisions++;
5280 if (bitmap_c[idx2] & val2) collisions++;
5281 if (bitmap_d[idx3] & val3) collisions++;
5282
5283 bitmap_a[idx0] |= val0;
5284 bitmap_b[idx1] |= val1;
5285 bitmap_c[idx2] |= val2;
5286 bitmap_d[idx3] |= val3;
5287
5288 if (collisions >= collisions_max) return 0x7fffffff;
5289 }
5290
5291 return collisions;
5292 }
5293
5294 /**
5295 * main
5296 */
5297
5298 int main (int argc, char **argv)
5299 {
5300 /**
5301 * To help users a bit
5302 */
5303
5304 char *compute = getenv ("COMPUTE");
5305
5306 if (compute)
5307 {
5308 static char display[100];
5309
5310 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5311
5312 putenv (display);
5313 }
5314 else
5315 {
5316 if (getenv ("DISPLAY") == NULL)
5317 putenv ((char *) "DISPLAY=:0");
5318 }
5319
5320 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5321 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5322
5323 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5324 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5325
5326 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5327 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5328
5329 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5330 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5331
5332 /**
5333 * Real init
5334 */
5335
5336 memset (&data, 0, sizeof (hc_global_data_t));
5337
5338 time_t proc_start;
5339
5340 time (&proc_start);
5341
5342 data.proc_start = proc_start;
5343
5344 int myargc = argc;
5345 char **myargv = argv;
5346
5347 hc_thread_mutex_init (mux_dispatcher);
5348 hc_thread_mutex_init (mux_counter);
5349 hc_thread_mutex_init (mux_display);
5350 hc_thread_mutex_init (mux_adl);
5351
5352 /**
5353 * commandline parameters
5354 */
5355
5356 uint usage = USAGE;
5357 uint version = VERSION;
5358 uint quiet = QUIET;
5359 uint benchmark = BENCHMARK;
5360 uint benchmark_repeats = BENCHMARK_REPEATS;
5361 uint show = SHOW;
5362 uint left = LEFT;
5363 uint username = USERNAME;
5364 uint remove = REMOVE;
5365 uint remove_timer = REMOVE_TIMER;
5366 u64 skip = SKIP;
5367 u64 limit = LIMIT;
5368 uint keyspace = KEYSPACE;
5369 uint potfile_disable = POTFILE_DISABLE;
5370 uint debug_mode = DEBUG_MODE;
5371 char *debug_file = NULL;
5372 char *induction_dir = NULL;
5373 char *outfile_check_dir = NULL;
5374 uint force = FORCE;
5375 uint runtime = RUNTIME;
5376 uint hash_mode = HASH_MODE;
5377 uint attack_mode = ATTACK_MODE;
5378 uint markov_disable = MARKOV_DISABLE;
5379 uint markov_classic = MARKOV_CLASSIC;
5380 uint markov_threshold = MARKOV_THRESHOLD;
5381 char *markov_hcstat = NULL;
5382 char *outfile = NULL;
5383 uint outfile_format = OUTFILE_FORMAT;
5384 uint outfile_autohex = OUTFILE_AUTOHEX;
5385 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5386 uint restore = RESTORE;
5387 uint restore_timer = RESTORE_TIMER;
5388 uint restore_disable = RESTORE_DISABLE;
5389 uint status = STATUS;
5390 uint status_timer = STATUS_TIMER;
5391 uint status_automat = STATUS_AUTOMAT;
5392 uint loopback = LOOPBACK;
5393 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5394 char *session = NULL;
5395 uint hex_charset = HEX_CHARSET;
5396 uint hex_salt = HEX_SALT;
5397 uint hex_wordlist = HEX_WORDLIST;
5398 uint rp_gen = RP_GEN;
5399 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5400 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5401 uint rp_gen_seed = RP_GEN_SEED;
5402 char *rule_buf_l = (char *) RULE_BUF_L;
5403 char *rule_buf_r = (char *) RULE_BUF_R;
5404 uint increment = INCREMENT;
5405 uint increment_min = INCREMENT_MIN;
5406 uint increment_max = INCREMENT_MAX;
5407 char *cpu_affinity = NULL;
5408 OCL_PTR *ocl = NULL;
5409 char *opencl_devices = NULL;
5410 char *opencl_platforms = NULL;
5411 char *opencl_device_types = NULL;
5412 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5413 char *truecrypt_keyfiles = NULL;
5414 uint workload_profile = WORKLOAD_PROFILE;
5415 uint kernel_accel = KERNEL_ACCEL;
5416 uint kernel_loops = KERNEL_LOOPS;
5417 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5418 #ifdef HAVE_HWMON
5419 uint gpu_temp_abort = GPU_TEMP_ABORT;
5420 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5421 #ifdef HAVE_ADL
5422 uint powertune_enable = POWERTUNE_ENABLE;
5423 #endif
5424 #endif
5425 uint logfile_disable = LOGFILE_DISABLE;
5426 uint segment_size = SEGMENT_SIZE;
5427 uint scrypt_tmto = SCRYPT_TMTO;
5428 char separator = SEPARATOR;
5429 uint bitmap_min = BITMAP_MIN;
5430 uint bitmap_max = BITMAP_MAX;
5431 char *custom_charset_1 = NULL;
5432 char *custom_charset_2 = NULL;
5433 char *custom_charset_3 = NULL;
5434 char *custom_charset_4 = NULL;
5435
5436 #define IDX_HELP 'h'
5437 #define IDX_VERSION 'V'
5438 #define IDX_VERSION_LOWER 'v'
5439 #define IDX_QUIET 0xff02
5440 #define IDX_SHOW 0xff03
5441 #define IDX_LEFT 0xff04
5442 #define IDX_REMOVE 0xff05
5443 #define IDX_REMOVE_TIMER 0xff37
5444 #define IDX_SKIP 's'
5445 #define IDX_LIMIT 'l'
5446 #define IDX_KEYSPACE 0xff35
5447 #define IDX_POTFILE_DISABLE 0xff06
5448 #define IDX_DEBUG_MODE 0xff43
5449 #define IDX_DEBUG_FILE 0xff44
5450 #define IDX_INDUCTION_DIR 0xff46
5451 #define IDX_OUTFILE_CHECK_DIR 0xff47
5452 #define IDX_USERNAME 0xff07
5453 #define IDX_FORCE 0xff08
5454 #define IDX_RUNTIME 0xff09
5455 #define IDX_BENCHMARK 'b'
5456 #define IDX_BENCHMARK_REPEATS 0xff78
5457 #define IDX_HASH_MODE 'm'
5458 #define IDX_ATTACK_MODE 'a'
5459 #define IDX_RP_FILE 'r'
5460 #define IDX_RP_GEN 'g'
5461 #define IDX_RP_GEN_FUNC_MIN 0xff10
5462 #define IDX_RP_GEN_FUNC_MAX 0xff11
5463 #define IDX_RP_GEN_SEED 0xff34
5464 #define IDX_RULE_BUF_L 'j'
5465 #define IDX_RULE_BUF_R 'k'
5466 #define IDX_INCREMENT 'i'
5467 #define IDX_INCREMENT_MIN 0xff12
5468 #define IDX_INCREMENT_MAX 0xff13
5469 #define IDX_OUTFILE 'o'
5470 #define IDX_OUTFILE_FORMAT 0xff14
5471 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5472 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5473 #define IDX_RESTORE 0xff15
5474 #define IDX_RESTORE_DISABLE 0xff27
5475 #define IDX_STATUS 0xff17
5476 #define IDX_STATUS_TIMER 0xff18
5477 #define IDX_STATUS_AUTOMAT 0xff50
5478 #define IDX_LOOPBACK 0xff38
5479 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5480 #define IDX_SESSION 0xff19
5481 #define IDX_HEX_CHARSET 0xff20
5482 #define IDX_HEX_SALT 0xff21
5483 #define IDX_HEX_WORDLIST 0xff40
5484 #define IDX_MARKOV_DISABLE 0xff22
5485 #define IDX_MARKOV_CLASSIC 0xff23
5486 #define IDX_MARKOV_THRESHOLD 't'
5487 #define IDX_MARKOV_HCSTAT 0xff24
5488 #define IDX_CPU_AFFINITY 0xff25
5489 #define IDX_OPENCL_DEVICES 'd'
5490 #define IDX_OPENCL_PLATFORMS 0xff72
5491 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5492 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5493 #define IDX_WORKLOAD_PROFILE 'w'
5494 #define IDX_KERNEL_ACCEL 'n'
5495 #define IDX_KERNEL_LOOPS 'u'
5496 #define IDX_GPU_TEMP_DISABLE 0xff29
5497 #define IDX_GPU_TEMP_ABORT 0xff30
5498 #define IDX_GPU_TEMP_RETAIN 0xff31
5499 #define IDX_POWERTUNE_ENABLE 0xff41
5500 #define IDX_LOGFILE_DISABLE 0xff51
5501 #define IDX_TRUECRYPT_KEYFILES 0xff52
5502 #define IDX_SCRYPT_TMTO 0xff61
5503 #define IDX_SEGMENT_SIZE 'c'
5504 #define IDX_SEPARATOR 'p'
5505 #define IDX_BITMAP_MIN 0xff70
5506 #define IDX_BITMAP_MAX 0xff71
5507 #define IDX_CUSTOM_CHARSET_1 '1'
5508 #define IDX_CUSTOM_CHARSET_2 '2'
5509 #define IDX_CUSTOM_CHARSET_3 '3'
5510 #define IDX_CUSTOM_CHARSET_4 '4'
5511
5512 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5513
5514 struct option long_options[] =
5515 {
5516 {"help", no_argument, 0, IDX_HELP},
5517 {"version", no_argument, 0, IDX_VERSION},
5518 {"quiet", no_argument, 0, IDX_QUIET},
5519 {"show", no_argument, 0, IDX_SHOW},
5520 {"left", no_argument, 0, IDX_LEFT},
5521 {"username", no_argument, 0, IDX_USERNAME},
5522 {"remove", no_argument, 0, IDX_REMOVE},
5523 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5524 {"skip", required_argument, 0, IDX_SKIP},
5525 {"limit", required_argument, 0, IDX_LIMIT},
5526 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5527 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5528 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5529 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5530 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5531 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5532 {"force", no_argument, 0, IDX_FORCE},
5533 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5534 {"benchmark-repeats", required_argument, 0, IDX_BENCHMARK_REPEATS},
5535 {"restore", no_argument, 0, IDX_RESTORE},
5536 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5537 {"status", no_argument, 0, IDX_STATUS},
5538 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5539 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5540 {"loopback", no_argument, 0, IDX_LOOPBACK},
5541 {"weak-hash-threshold",
5542 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5543 {"session", required_argument, 0, IDX_SESSION},
5544 {"runtime", required_argument, 0, IDX_RUNTIME},
5545 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5546 {"generate-rules-func-min",
5547 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5548 {"generate-rules-func-max",
5549 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5550 {"generate-rules-seed",
5551 required_argument, 0, IDX_RP_GEN_SEED},
5552 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5553 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5554 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5555 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5556 {"rules-file", required_argument, 0, IDX_RP_FILE},
5557 {"outfile", required_argument, 0, IDX_OUTFILE},
5558 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5559 {"outfile-autohex-disable",
5560 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5561 {"outfile-check-timer",
5562 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5563 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5564 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5565 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5566 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5567 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5568 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5569 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5570 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5571 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5572 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5573 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5574 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5575 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5576 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5577 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5578 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5579 #ifdef HAVE_HWMON
5580 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5581 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5582 #ifdef HAVE_ADL
5583 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5584 #endif
5585 #endif // HAVE_HWMON
5586 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5587 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5588 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5589 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5590 // deprecated
5591 {"seperator", required_argument, 0, IDX_SEPARATOR},
5592 {"separator", required_argument, 0, IDX_SEPARATOR},
5593 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5594 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5595 {"increment", no_argument, 0, IDX_INCREMENT},
5596 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5597 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5598 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5599 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5600 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5601 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5602
5603 {0, 0, 0, 0}
5604 };
5605
5606 uint rp_files_cnt = 0;
5607
5608 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5609
5610 int option_index = 0;
5611 int c = -1;
5612
5613 optind = 1;
5614 optopt = 0;
5615
5616 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5617 {
5618 switch (c)
5619 {
5620 case IDX_HELP: usage = 1; break;
5621 case IDX_VERSION:
5622 case IDX_VERSION_LOWER: version = 1; break;
5623 case IDX_RESTORE: restore = 1; break;
5624 case IDX_SESSION: session = optarg; break;
5625 case IDX_SHOW: show = 1; break;
5626 case IDX_LEFT: left = 1; break;
5627 case '?': return (-1);
5628 }
5629 }
5630
5631 if (optopt != 0)
5632 {
5633 log_error ("ERROR: Invalid argument specified");
5634
5635 return (-1);
5636 }
5637
5638 /**
5639 * exit functions
5640 */
5641
5642 if (version)
5643 {
5644 log_info ("%s (%s)", VERSION_TAG, VERSION_SUM);
5645
5646 return (0);
5647 }
5648
5649 if (usage)
5650 {
5651 usage_big_print (PROGNAME);
5652
5653 return (0);
5654 }
5655
5656 /**
5657 * session needs to be set, always!
5658 */
5659
5660 if (session == NULL) session = (char *) PROGNAME;
5661
5662 /**
5663 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5664 */
5665
5666 char *exec_path = get_exec_path ();
5667
5668 #ifdef LINUX
5669
5670 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5671 char *resolved_exec_path = realpath (exec_path, NULL);
5672
5673 char *install_dir = get_install_dir (resolved_exec_path);
5674 char *profile_dir = NULL;
5675 char *session_dir = NULL;
5676 char *shared_dir = NULL;
5677
5678 if (strcmp (install_dir, resolved_install_folder) == 0)
5679 {
5680 struct passwd *pw = getpwuid (getuid ());
5681
5682 const char *homedir = pw->pw_dir;
5683
5684 profile_dir = get_profile_dir (homedir);
5685 session_dir = get_session_dir (profile_dir);
5686 shared_dir = strdup (SHARED_FOLDER);
5687
5688 mkdir (profile_dir, 0700);
5689 mkdir (session_dir, 0700);
5690 }
5691 else
5692 {
5693 profile_dir = install_dir;
5694 session_dir = install_dir;
5695 shared_dir = install_dir;
5696 }
5697
5698 myfree (resolved_install_folder);
5699 myfree (resolved_exec_path);
5700
5701 #else
5702
5703 char *install_dir = get_install_dir (exec_path);
5704 char *profile_dir = install_dir;
5705 char *session_dir = install_dir;
5706 char *shared_dir = install_dir;
5707
5708 #endif
5709
5710 data.install_dir = install_dir;
5711 data.profile_dir = profile_dir;
5712 data.session_dir = session_dir;
5713 data.shared_dir = shared_dir;
5714
5715 myfree (exec_path);
5716
5717 /**
5718 * kernel cache, we need to make sure folder exist
5719 */
5720
5721 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5722
5723 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5724
5725 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5726
5727 mkdir (kernels_folder, 0700);
5728
5729 myfree (kernels_folder);
5730
5731 /**
5732 * session
5733 */
5734
5735 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5736
5737 data.session = session;
5738
5739 char *eff_restore_file = (char *) mymalloc (session_size);
5740 char *new_restore_file = (char *) mymalloc (session_size);
5741
5742 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5743 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5744
5745 data.eff_restore_file = eff_restore_file;
5746 data.new_restore_file = new_restore_file;
5747
5748 if (((show == 1) || (left == 1)) && (restore == 1))
5749 {
5750 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5751 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5752
5753 return (-1);
5754 }
5755
5756 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5757 if ((show == 1) || (left == 1))
5758 {
5759 restore_disable = 1;
5760
5761 restore = 0;
5762 }
5763
5764 data.restore_disable = restore_disable;
5765
5766 restore_data_t *rd = init_restore (argc, argv);
5767
5768 data.rd = rd;
5769
5770 /**
5771 * restore file
5772 */
5773
5774 if (restore == 1)
5775 {
5776 read_restore (eff_restore_file, rd);
5777
5778 if (rd->version_bin < RESTORE_MIN)
5779 {
5780 log_error ("ERROR: Incompatible restore-file version");
5781
5782 return (-1);
5783 }
5784
5785 myargc = rd->argc;
5786 myargv = rd->argv;
5787
5788 #ifdef _POSIX
5789 rd->pid = getpid ();
5790 #elif _WIN
5791 rd->pid = GetCurrentProcessId ();
5792 #endif
5793 }
5794
5795 uint hash_mode_chgd = 0;
5796 uint runtime_chgd = 0;
5797 uint kernel_loops_chgd = 0;
5798 uint kernel_accel_chgd = 0;
5799 uint attack_mode_chgd = 0;
5800 uint outfile_format_chgd = 0;
5801 uint rp_gen_seed_chgd = 0;
5802 uint remove_timer_chgd = 0;
5803 uint increment_min_chgd = 0;
5804 uint increment_max_chgd = 0;
5805 uint workload_profile_chgd = 0;
5806 uint opencl_vector_width_chgd = 0;
5807
5808 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5809 uint gpu_temp_retain_chgd = 0;
5810 uint gpu_temp_abort_chgd = 0;
5811 #endif
5812
5813 optind = 1;
5814 optopt = 0;
5815 option_index = 0;
5816
5817 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5818 {
5819 switch (c)
5820 {
5821 //case IDX_HELP: usage = 1; break;
5822 //case IDX_VERSION: version = 1; break;
5823 //case IDX_RESTORE: restore = 1; break;
5824 case IDX_QUIET: quiet = 1; break;
5825 //case IDX_SHOW: show = 1; break;
5826 case IDX_SHOW: break;
5827 //case IDX_LEFT: left = 1; break;
5828 case IDX_LEFT: break;
5829 case IDX_USERNAME: username = 1; break;
5830 case IDX_REMOVE: remove = 1; break;
5831 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5832 remove_timer_chgd = 1; break;
5833 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5834 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5835 case IDX_DEBUG_FILE: debug_file = optarg; break;
5836 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5837 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5838 case IDX_FORCE: force = 1; break;
5839 case IDX_SKIP: skip = atoll (optarg); break;
5840 case IDX_LIMIT: limit = atoll (optarg); break;
5841 case IDX_KEYSPACE: keyspace = 1; break;
5842 case IDX_BENCHMARK: benchmark = 1; break;
5843 case IDX_BENCHMARK_REPEATS: benchmark_repeats = atoi (optarg); break;
5844 case IDX_RESTORE: break;
5845 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5846 case IDX_STATUS: status = 1; break;
5847 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5848 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5849 case IDX_LOOPBACK: loopback = 1; break;
5850 case IDX_WEAK_HASH_THRESHOLD:
5851 weak_hash_threshold = atoi (optarg); break;
5852 //case IDX_SESSION: session = optarg; break;
5853 case IDX_SESSION: break;
5854 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5855 hash_mode_chgd = 1; break;
5856 case IDX_RUNTIME: runtime = atoi (optarg);
5857 runtime_chgd = 1; break;
5858 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5859 attack_mode_chgd = 1; break;
5860 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5861 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5862 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5863 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5864 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5865 rp_gen_seed_chgd = 1; break;
5866 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5867 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5868 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5869 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5870 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5871 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5872 case IDX_OUTFILE: outfile = optarg; break;
5873 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5874 outfile_format_chgd = 1; break;
5875 case IDX_OUTFILE_AUTOHEX_DISABLE:
5876 outfile_autohex = 0; break;
5877 case IDX_OUTFILE_CHECK_TIMER:
5878 outfile_check_timer = atoi (optarg); break;
5879 case IDX_HEX_CHARSET: hex_charset = 1; break;
5880 case IDX_HEX_SALT: hex_salt = 1; break;
5881 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5882 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5883 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5884 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5885 case IDX_OPENCL_DEVICE_TYPES:
5886 opencl_device_types = optarg; break;
5887 case IDX_OPENCL_VECTOR_WIDTH:
5888 opencl_vector_width = atoi (optarg);
5889 opencl_vector_width_chgd = 1; break;
5890 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
5891 workload_profile_chgd = 1; break;
5892 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5893 kernel_accel_chgd = 1; break;
5894 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5895 kernel_loops_chgd = 1; break;
5896 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5897 #ifdef HAVE_HWMON
5898 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5899 #ifdef HAVE_ADL
5900 gpu_temp_abort_chgd = 1;
5901 #endif
5902 break;
5903 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5904 #ifdef HAVE_ADL
5905 gpu_temp_retain_chgd = 1;
5906 #endif
5907 break;
5908 #ifdef HAVE_ADL
5909 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5910 #endif
5911 #endif // HAVE_HWMON
5912 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5913 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5914 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5915 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5916 case IDX_SEPARATOR: separator = optarg[0]; break;
5917 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5918 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5919 case IDX_INCREMENT: increment = 1; break;
5920 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5921 increment_min_chgd = 1; break;
5922 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5923 increment_max_chgd = 1; break;
5924 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5925 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5926 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5927 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5928
5929 default:
5930 log_error ("ERROR: Invalid argument specified");
5931 return (-1);
5932 }
5933 }
5934
5935 if (optopt != 0)
5936 {
5937 log_error ("ERROR: Invalid argument specified");
5938
5939 return (-1);
5940 }
5941
5942 /**
5943 * Inform user things getting started,
5944 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5945 * - we do not need to check algorithm_pos
5946 */
5947
5948 if (quiet == 0)
5949 {
5950 if (benchmark == 1)
5951 {
5952 log_info ("%s %s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5953
5954 log_info ("");
5955 }
5956 else if (restore == 1)
5957 {
5958 log_info ("%s %s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5959
5960 log_info ("");
5961 }
5962 else
5963 {
5964 log_info ("%s %s (%s) starting...", PROGNAME, VERSION_TAG, VERSION_SUM);
5965
5966 log_info ("");
5967 }
5968 }
5969
5970 /**
5971 * sanity check
5972 */
5973
5974 if (attack_mode > 7)
5975 {
5976 log_error ("ERROR: Invalid attack-mode specified");
5977
5978 return (-1);
5979 }
5980
5981 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5982 {
5983 log_error ("ERROR: Invalid runtime specified");
5984
5985 return (-1);
5986 }
5987
5988 if (hash_mode_chgd && hash_mode > 13400) // just added to remove compiler warnings for hash_mode_chgd
5989 {
5990 log_error ("ERROR: Invalid hash-type specified");
5991
5992 return (-1);
5993 }
5994
5995 // renamed hash modes
5996
5997 if (hash_mode_chgd)
5998 {
5999 int n = -1;
6000
6001 switch (hash_mode)
6002 {
6003 case 123: n = 124;
6004 break;
6005 }
6006
6007 if (n >= 0)
6008 {
6009 log_error ("Old -m specified, use -m %d instead", n);
6010
6011 return (-1);
6012 }
6013 }
6014
6015 if (username == 1)
6016 {
6017 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
6018 {
6019 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6020
6021 return (-1);
6022 }
6023 }
6024
6025 if (outfile_format > 16)
6026 {
6027 log_error ("ERROR: Invalid outfile-format specified");
6028
6029 return (-1);
6030 }
6031
6032 if (left == 1)
6033 {
6034 if (outfile_format_chgd == 1)
6035 {
6036 if (outfile_format > 1)
6037 {
6038 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6039
6040 return (-1);
6041 }
6042 }
6043 else
6044 {
6045 outfile_format = OUTFILE_FMT_HASH;
6046 }
6047 }
6048
6049 if (show == 1)
6050 {
6051 if (outfile_format_chgd == 1)
6052 {
6053 if ((outfile_format > 7) && (outfile_format < 16))
6054 {
6055 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6056
6057 return (-1);
6058 }
6059 }
6060 }
6061
6062 if (increment_min < INCREMENT_MIN)
6063 {
6064 log_error ("ERROR: Invalid increment-min specified");
6065
6066 return (-1);
6067 }
6068
6069 if (increment_max > INCREMENT_MAX)
6070 {
6071 log_error ("ERROR: Invalid increment-max specified");
6072
6073 return (-1);
6074 }
6075
6076 if (increment_min > increment_max)
6077 {
6078 log_error ("ERROR: Invalid increment-min specified");
6079
6080 return (-1);
6081 }
6082
6083 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6084 {
6085 log_error ("ERROR: increment is not allowed in attack-mode 0");
6086
6087 return (-1);
6088 }
6089
6090 if ((increment == 0) && (increment_min_chgd == 1))
6091 {
6092 log_error ("ERROR: increment-min is only supported together with increment switch");
6093
6094 return (-1);
6095 }
6096
6097 if ((increment == 0) && (increment_max_chgd == 1))
6098 {
6099 log_error ("ERROR: increment-max is only supported together with increment switch");
6100
6101 return (-1);
6102 }
6103
6104 if (rp_files_cnt && rp_gen)
6105 {
6106 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6107
6108 return (-1);
6109 }
6110
6111 if (rp_files_cnt || rp_gen)
6112 {
6113 if (attack_mode != ATTACK_MODE_STRAIGHT)
6114 {
6115 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6116
6117 return (-1);
6118 }
6119 }
6120
6121 if (rp_gen_func_min > rp_gen_func_max)
6122 {
6123 log_error ("ERROR: Invalid rp-gen-func-min specified");
6124
6125 return (-1);
6126 }
6127
6128 if (kernel_accel_chgd == 1)
6129 {
6130 if (kernel_accel < 1)
6131 {
6132 log_error ("ERROR: Invalid kernel-accel specified");
6133
6134 return (-1);
6135 }
6136
6137 if (kernel_accel > 1024)
6138 {
6139 log_error ("ERROR: Invalid kernel-accel specified");
6140
6141 return (-1);
6142 }
6143 }
6144
6145 if (kernel_loops_chgd == 1)
6146 {
6147 if (kernel_loops < 1)
6148 {
6149 log_error ("ERROR: Invalid kernel-loops specified");
6150
6151 return (-1);
6152 }
6153
6154 if (kernel_loops > 1024)
6155 {
6156 log_error ("ERROR: Invalid kernel-loops specified");
6157
6158 return (-1);
6159 }
6160 }
6161
6162 if ((workload_profile < 1) || (workload_profile > 3))
6163 {
6164 log_error ("ERROR: workload-profile %i not available", workload_profile);
6165
6166 return (-1);
6167 }
6168
6169 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6170 {
6171 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6172
6173 return (-1);
6174 }
6175
6176 if (show == 1 || left == 1)
6177 {
6178 attack_mode = ATTACK_MODE_NONE;
6179
6180 if (remove == 1)
6181 {
6182 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6183
6184 return (-1);
6185 }
6186
6187 if (potfile_disable == 1)
6188 {
6189 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6190
6191 return (-1);
6192 }
6193 }
6194
6195 uint attack_kern = ATTACK_KERN_NONE;
6196
6197 switch (attack_mode)
6198 {
6199 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6200 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6201 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6202 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6203 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6204 }
6205
6206 if (benchmark == 0)
6207 {
6208 if (keyspace == 1)
6209 {
6210 int num_additional_params = 1;
6211
6212 if (attack_kern == ATTACK_KERN_COMBI)
6213 {
6214 num_additional_params = 2;
6215 }
6216
6217 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6218
6219 if (keyspace_wordlist_specified == 0) optind--;
6220 }
6221
6222 if (attack_kern == ATTACK_KERN_NONE)
6223 {
6224 if ((optind + 1) != myargc)
6225 {
6226 usage_mini_print (myargv[0]);
6227
6228 return (-1);
6229 }
6230 }
6231 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6232 {
6233 if ((optind + 1) > myargc)
6234 {
6235 usage_mini_print (myargv[0]);
6236
6237 return (-1);
6238 }
6239 }
6240 else if (attack_kern == ATTACK_KERN_COMBI)
6241 {
6242 if ((optind + 3) != myargc)
6243 {
6244 usage_mini_print (myargv[0]);
6245
6246 return (-1);
6247 }
6248 }
6249 else if (attack_kern == ATTACK_KERN_BF)
6250 {
6251 if ((optind + 1) > myargc)
6252 {
6253 usage_mini_print (myargv[0]);
6254
6255 return (-1);
6256 }
6257 }
6258 else
6259 {
6260 usage_mini_print (myargv[0]);
6261
6262 return (-1);
6263 }
6264 }
6265 else
6266 {
6267 if (myargv[optind] != 0)
6268 {
6269 log_error ("ERROR: Invalid argument for benchmark mode specified");
6270
6271 return (-1);
6272 }
6273
6274 if (attack_mode_chgd == 1)
6275 {
6276 if (attack_mode != ATTACK_MODE_BF)
6277 {
6278 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6279
6280 return (-1);
6281 }
6282 }
6283 }
6284
6285 if (skip != 0 && limit != 0)
6286 {
6287 limit += skip;
6288 }
6289
6290 if (keyspace == 1)
6291 {
6292 if (show == 1)
6293 {
6294 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6295
6296 return (-1);
6297 }
6298 else if (left == 1)
6299 {
6300 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6301
6302 return (-1);
6303 }
6304
6305 potfile_disable = 1;
6306
6307 restore_disable = 1;
6308
6309 restore = 0;
6310
6311 weak_hash_threshold = 0;
6312
6313 quiet = 1;
6314 }
6315
6316 if (remove_timer_chgd == 1)
6317 {
6318 if (remove == 0)
6319 {
6320 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6321
6322 return (-1);
6323 }
6324
6325 if (remove_timer < 1)
6326 {
6327 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6328
6329 return (-1);
6330 }
6331 }
6332
6333 if (loopback == 1)
6334 {
6335 if (attack_mode == ATTACK_MODE_BF)
6336 {
6337 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
6338
6339 return (-1);
6340 }
6341 else if (attack_mode == ATTACK_MODE_STRAIGHT)
6342 {
6343 if ((rp_files_cnt == 0) && (rp_gen == 0))
6344 {
6345 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6346
6347 return (-1);
6348 }
6349 }
6350 }
6351
6352 if (debug_mode > 0)
6353 {
6354 if (attack_mode != ATTACK_MODE_STRAIGHT)
6355 {
6356 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6357
6358 return (-1);
6359 }
6360
6361 if ((rp_files_cnt == 0) && (rp_gen == 0))
6362 {
6363 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6364
6365 return (-1);
6366 }
6367 }
6368
6369 if (debug_mode > 4)
6370 {
6371 log_error ("ERROR: Invalid debug-mode specified");
6372
6373 return (-1);
6374 }
6375
6376 if (debug_file != NULL)
6377 {
6378 if (debug_mode < 1)
6379 {
6380 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6381
6382 return (-1);
6383 }
6384 }
6385
6386 if (induction_dir != NULL)
6387 {
6388 if (attack_mode == ATTACK_MODE_BF)
6389 {
6390 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6391
6392 return (-1);
6393 }
6394 }
6395
6396 if (attack_mode != ATTACK_MODE_STRAIGHT)
6397 {
6398 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6399 {
6400 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6401
6402 return (-1);
6403 }
6404
6405 weak_hash_threshold = 0;
6406 }
6407
6408 /**
6409 * induction directory
6410 */
6411
6412 char *induction_directory = NULL;
6413
6414 if (attack_mode != ATTACK_MODE_BF)
6415 {
6416 if (induction_dir == NULL)
6417 {
6418 induction_directory = (char *) mymalloc (session_size);
6419
6420 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6421
6422 // create induction folder if it does not already exist
6423
6424 if (keyspace == 0)
6425 {
6426 if (rmdir (induction_directory) == -1)
6427 {
6428 if (errno == ENOENT)
6429 {
6430 // good, we can ignore
6431 }
6432 else if (errno == ENOTEMPTY)
6433 {
6434 char *induction_directory_mv = (char *) mymalloc (session_size);
6435
6436 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6437
6438 if (rename (induction_directory, induction_directory_mv) != 0)
6439 {
6440 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6441
6442 return (-1);
6443 }
6444 }
6445 else
6446 {
6447 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6448
6449 return (-1);
6450 }
6451 }
6452
6453 if (mkdir (induction_directory, 0700) == -1)
6454 {
6455 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6456
6457 return (-1);
6458 }
6459 }
6460 }
6461 else
6462 {
6463 induction_directory = induction_dir;
6464 }
6465 }
6466
6467 data.induction_directory = induction_directory;
6468
6469 /**
6470 * loopback
6471 */
6472
6473 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6474
6475 char *loopback_file = (char *) mymalloc (loopback_size);
6476
6477 /**
6478 * tuning db
6479 */
6480
6481 char tuning_db_file[256] = { 0 };
6482
6483 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6484
6485 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6486
6487 /**
6488 * outfile-check directory
6489 */
6490
6491 char *outfile_check_directory = NULL;
6492
6493 if (outfile_check_dir == NULL)
6494 {
6495 outfile_check_directory = (char *) mymalloc (session_size);
6496
6497 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6498 }
6499 else
6500 {
6501 outfile_check_directory = outfile_check_dir;
6502 }
6503
6504 data.outfile_check_directory = outfile_check_directory;
6505
6506 if (keyspace == 0)
6507 {
6508 struct stat outfile_check_stat;
6509
6510 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6511 {
6512 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6513
6514 if (is_dir == 0)
6515 {
6516 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6517
6518 return (-1);
6519 }
6520 }
6521 else if (outfile_check_dir == NULL)
6522 {
6523 if (mkdir (outfile_check_directory, 0700) == -1)
6524 {
6525 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6526
6527 return (-1);
6528 }
6529 }
6530 }
6531
6532 /**
6533 * special other stuff
6534 */
6535
6536 if (hash_mode == 9710)
6537 {
6538 outfile_format = 5;
6539 outfile_format_chgd = 1;
6540 }
6541
6542 if (hash_mode == 9810)
6543 {
6544 outfile_format = 5;
6545 outfile_format_chgd = 1;
6546 }
6547
6548 if (hash_mode == 10410)
6549 {
6550 outfile_format = 5;
6551 outfile_format_chgd = 1;
6552 }
6553
6554 /**
6555 * store stuff
6556 */
6557
6558 data.hash_mode = hash_mode;
6559 data.restore = restore;
6560 data.restore_timer = restore_timer;
6561 data.restore_disable = restore_disable;
6562 data.status = status;
6563 data.status_timer = status_timer;
6564 data.status_automat = status_automat;
6565 data.loopback = loopback;
6566 data.runtime = runtime;
6567 data.remove = remove;
6568 data.remove_timer = remove_timer;
6569 data.debug_mode = debug_mode;
6570 data.debug_file = debug_file;
6571 data.username = username;
6572 data.quiet = quiet;
6573 data.outfile = outfile;
6574 data.outfile_format = outfile_format;
6575 data.outfile_autohex = outfile_autohex;
6576 data.hex_charset = hex_charset;
6577 data.hex_salt = hex_salt;
6578 data.hex_wordlist = hex_wordlist;
6579 data.separator = separator;
6580 data.rp_files = rp_files;
6581 data.rp_files_cnt = rp_files_cnt;
6582 data.rp_gen = rp_gen;
6583 data.rp_gen_seed = rp_gen_seed;
6584 data.force = force;
6585 data.benchmark = benchmark;
6586 data.benchmark_repeats = benchmark_repeats;
6587 data.skip = skip;
6588 data.limit = limit;
6589 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6590 data.powertune_enable = powertune_enable;
6591 #endif
6592 data.logfile_disable = logfile_disable;
6593 data.truecrypt_keyfiles = truecrypt_keyfiles;
6594 data.scrypt_tmto = scrypt_tmto;
6595 data.workload_profile = workload_profile;
6596
6597 /**
6598 * cpu affinity
6599 */
6600
6601 if (cpu_affinity)
6602 {
6603 set_cpu_affinity (cpu_affinity);
6604 }
6605
6606 if (rp_gen_seed_chgd == 0)
6607 {
6608 srand (proc_start);
6609 }
6610 else
6611 {
6612 srand (rp_gen_seed);
6613 }
6614
6615 /**
6616 * logfile init
6617 */
6618
6619 if (logfile_disable == 0)
6620 {
6621 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6622
6623 char *logfile = (char *) mymalloc (logfile_size);
6624
6625 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6626
6627 data.logfile = logfile;
6628
6629 char *topid = logfile_generate_topid ();
6630
6631 data.topid = topid;
6632 }
6633
6634 // logfile_append() checks for logfile_disable internally to make it easier from here
6635
6636 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6637 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6638 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6639 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6640 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6641 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6642 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6643 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6644 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6645 #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));
6646
6647 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6648 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6649 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6650 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6651 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6652 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6653 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6654 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6655
6656 logfile_top_msg ("START");
6657
6658 logfile_top_uint (attack_mode);
6659 logfile_top_uint (attack_kern);
6660 logfile_top_uint (benchmark);
6661 logfile_top_uint (benchmark_repeats);
6662 logfile_top_uint (bitmap_min);
6663 logfile_top_uint (bitmap_max);
6664 logfile_top_uint (debug_mode);
6665 logfile_top_uint (force);
6666 logfile_top_uint (kernel_accel);
6667 logfile_top_uint (kernel_loops);
6668 logfile_top_uint (gpu_temp_disable);
6669 #ifdef HAVE_HWMON
6670 logfile_top_uint (gpu_temp_abort);
6671 logfile_top_uint (gpu_temp_retain);
6672 #endif
6673 logfile_top_uint (hash_mode);
6674 logfile_top_uint (hex_charset);
6675 logfile_top_uint (hex_salt);
6676 logfile_top_uint (hex_wordlist);
6677 logfile_top_uint (increment);
6678 logfile_top_uint (increment_max);
6679 logfile_top_uint (increment_min);
6680 logfile_top_uint (keyspace);
6681 logfile_top_uint (left);
6682 logfile_top_uint (logfile_disable);
6683 logfile_top_uint (loopback);
6684 logfile_top_uint (markov_classic);
6685 logfile_top_uint (markov_disable);
6686 logfile_top_uint (markov_threshold);
6687 logfile_top_uint (outfile_autohex);
6688 logfile_top_uint (outfile_check_timer);
6689 logfile_top_uint (outfile_format);
6690 logfile_top_uint (potfile_disable);
6691 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6692 logfile_top_uint (powertune_enable);
6693 #endif
6694 logfile_top_uint (scrypt_tmto);
6695 logfile_top_uint (quiet);
6696 logfile_top_uint (remove);
6697 logfile_top_uint (remove_timer);
6698 logfile_top_uint (restore);
6699 logfile_top_uint (restore_disable);
6700 logfile_top_uint (restore_timer);
6701 logfile_top_uint (rp_gen);
6702 logfile_top_uint (rp_gen_func_max);
6703 logfile_top_uint (rp_gen_func_min);
6704 logfile_top_uint (rp_gen_seed);
6705 logfile_top_uint (runtime);
6706 logfile_top_uint (segment_size);
6707 logfile_top_uint (show);
6708 logfile_top_uint (status);
6709 logfile_top_uint (status_automat);
6710 logfile_top_uint (status_timer);
6711 logfile_top_uint (usage);
6712 logfile_top_uint (username);
6713 logfile_top_uint (version);
6714 logfile_top_uint (weak_hash_threshold);
6715 logfile_top_uint (workload_profile);
6716 logfile_top_uint64 (limit);
6717 logfile_top_uint64 (skip);
6718 logfile_top_char (separator);
6719 logfile_top_string (cpu_affinity);
6720 logfile_top_string (custom_charset_1);
6721 logfile_top_string (custom_charset_2);
6722 logfile_top_string (custom_charset_3);
6723 logfile_top_string (custom_charset_4);
6724 logfile_top_string (debug_file);
6725 logfile_top_string (opencl_devices);
6726 logfile_top_string (opencl_platforms);
6727 logfile_top_string (opencl_device_types);
6728 logfile_top_uint (opencl_vector_width);
6729 logfile_top_string (induction_dir);
6730 logfile_top_string (markov_hcstat);
6731 logfile_top_string (outfile);
6732 logfile_top_string (outfile_check_dir);
6733 logfile_top_string (rule_buf_l);
6734 logfile_top_string (rule_buf_r);
6735 logfile_top_string (session);
6736 logfile_top_string (truecrypt_keyfiles);
6737
6738 /**
6739 * Init OpenCL library loader
6740 */
6741
6742 if (keyspace == 0)
6743 {
6744 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6745
6746 ocl_init (ocl);
6747
6748 data.ocl = ocl;
6749 }
6750
6751 /**
6752 * OpenCL platform selection
6753 */
6754
6755 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6756
6757 /**
6758 * OpenCL device selection
6759 */
6760
6761 u32 devices_filter = setup_devices_filter (opencl_devices);
6762
6763 /**
6764 * OpenCL device type selection
6765 */
6766
6767 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6768
6769 /**
6770 * benchmark
6771 */
6772
6773 if (benchmark == 1)
6774 {
6775 /**
6776 * disable useless stuff for benchmark
6777 */
6778
6779 status_timer = 0;
6780 restore_timer = 0;
6781 restore_disable = 1;
6782 potfile_disable = 1;
6783 weak_hash_threshold = 0;
6784 gpu_temp_disable = 1;
6785
6786 data.status_timer = status_timer;
6787 data.restore_timer = restore_timer;
6788 data.restore_disable = restore_disable;
6789
6790 /**
6791 * force attack mode to be bruteforce
6792 */
6793
6794 attack_mode = ATTACK_MODE_BF;
6795 attack_kern = ATTACK_KERN_BF;
6796
6797 if (workload_profile_chgd == 0)
6798 {
6799 workload_profile = 3;
6800
6801 data.workload_profile = workload_profile;
6802 }
6803 }
6804
6805 /**
6806 * config
6807 */
6808
6809 uint hash_type = 0;
6810 uint salt_type = 0;
6811 uint attack_exec = 0;
6812 uint opts_type = 0;
6813 uint kern_type = 0;
6814 uint dgst_size = 0;
6815 uint esalt_size = 0;
6816 uint opti_type = 0;
6817 uint dgst_pos0 = -1;
6818 uint dgst_pos1 = -1;
6819 uint dgst_pos2 = -1;
6820 uint dgst_pos3 = -1;
6821
6822 int (*parse_func) (char *, uint, hash_t *);
6823 int (*sort_by_digest) (const void *, const void *);
6824
6825 uint algorithm_pos = 0;
6826 uint algorithm_max = 1;
6827
6828 uint *algorithms = default_benchmark_algorithms;
6829
6830 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6831
6832 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6833 {
6834 /*
6835 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6836 * the following algos are skipped entirely
6837 */
6838
6839 if (algorithm_pos > 0)
6840 {
6841 local_free (rd);
6842
6843 rd = init_restore (argc, argv);
6844
6845 data.rd = rd;
6846 }
6847
6848 /**
6849 * update hash_mode in case of multihash benchmark
6850 */
6851
6852 if (benchmark == 1)
6853 {
6854 if (hash_mode_chgd == 0)
6855 {
6856 hash_mode = algorithms[algorithm_pos];
6857
6858 data.hash_mode = hash_mode;
6859 }
6860
6861 quiet = 1;
6862
6863 data.quiet = quiet;
6864 }
6865
6866 switch (hash_mode)
6867 {
6868 case 0: hash_type = HASH_TYPE_MD5;
6869 salt_type = SALT_TYPE_NONE;
6870 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6871 opts_type = OPTS_TYPE_PT_GENERATE_LE
6872 | OPTS_TYPE_PT_ADD80
6873 | OPTS_TYPE_PT_ADDBITS14;
6874 kern_type = KERN_TYPE_MD5;
6875 dgst_size = DGST_SIZE_4_4;
6876 parse_func = md5_parse_hash;
6877 sort_by_digest = sort_by_digest_4_4;
6878 opti_type = OPTI_TYPE_ZERO_BYTE
6879 | OPTI_TYPE_PRECOMPUTE_INIT
6880 | OPTI_TYPE_PRECOMPUTE_MERKLE
6881 | OPTI_TYPE_MEET_IN_MIDDLE
6882 | OPTI_TYPE_EARLY_SKIP
6883 | OPTI_TYPE_NOT_ITERATED
6884 | OPTI_TYPE_NOT_SALTED
6885 | OPTI_TYPE_RAW_HASH;
6886 dgst_pos0 = 0;
6887 dgst_pos1 = 3;
6888 dgst_pos2 = 2;
6889 dgst_pos3 = 1;
6890 break;
6891
6892 case 10: hash_type = HASH_TYPE_MD5;
6893 salt_type = SALT_TYPE_INTERN;
6894 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6895 opts_type = OPTS_TYPE_PT_GENERATE_LE
6896 | OPTS_TYPE_ST_ADD80
6897 | OPTS_TYPE_ST_ADDBITS14;
6898 kern_type = KERN_TYPE_MD5_PWSLT;
6899 dgst_size = DGST_SIZE_4_4;
6900 parse_func = md5s_parse_hash;
6901 sort_by_digest = sort_by_digest_4_4;
6902 opti_type = OPTI_TYPE_ZERO_BYTE
6903 | OPTI_TYPE_PRECOMPUTE_INIT
6904 | OPTI_TYPE_PRECOMPUTE_MERKLE
6905 | OPTI_TYPE_MEET_IN_MIDDLE
6906 | OPTI_TYPE_EARLY_SKIP
6907 | OPTI_TYPE_NOT_ITERATED
6908 | OPTI_TYPE_APPENDED_SALT
6909 | OPTI_TYPE_RAW_HASH;
6910 dgst_pos0 = 0;
6911 dgst_pos1 = 3;
6912 dgst_pos2 = 2;
6913 dgst_pos3 = 1;
6914 break;
6915
6916 case 11: hash_type = HASH_TYPE_MD5;
6917 salt_type = SALT_TYPE_INTERN;
6918 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6919 opts_type = OPTS_TYPE_PT_GENERATE_LE
6920 | OPTS_TYPE_ST_ADD80
6921 | OPTS_TYPE_ST_ADDBITS14;
6922 kern_type = KERN_TYPE_MD5_PWSLT;
6923 dgst_size = DGST_SIZE_4_4;
6924 parse_func = joomla_parse_hash;
6925 sort_by_digest = sort_by_digest_4_4;
6926 opti_type = OPTI_TYPE_ZERO_BYTE
6927 | OPTI_TYPE_PRECOMPUTE_INIT
6928 | OPTI_TYPE_PRECOMPUTE_MERKLE
6929 | OPTI_TYPE_MEET_IN_MIDDLE
6930 | OPTI_TYPE_EARLY_SKIP
6931 | OPTI_TYPE_NOT_ITERATED
6932 | OPTI_TYPE_APPENDED_SALT
6933 | OPTI_TYPE_RAW_HASH;
6934 dgst_pos0 = 0;
6935 dgst_pos1 = 3;
6936 dgst_pos2 = 2;
6937 dgst_pos3 = 1;
6938 break;
6939
6940 case 12: hash_type = HASH_TYPE_MD5;
6941 salt_type = SALT_TYPE_INTERN;
6942 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6943 opts_type = OPTS_TYPE_PT_GENERATE_LE
6944 | OPTS_TYPE_ST_ADD80
6945 | OPTS_TYPE_ST_ADDBITS14;
6946 kern_type = KERN_TYPE_MD5_PWSLT;
6947 dgst_size = DGST_SIZE_4_4;
6948 parse_func = postgresql_parse_hash;
6949 sort_by_digest = sort_by_digest_4_4;
6950 opti_type = OPTI_TYPE_ZERO_BYTE
6951 | OPTI_TYPE_PRECOMPUTE_INIT
6952 | OPTI_TYPE_PRECOMPUTE_MERKLE
6953 | OPTI_TYPE_MEET_IN_MIDDLE
6954 | OPTI_TYPE_EARLY_SKIP
6955 | OPTI_TYPE_NOT_ITERATED
6956 | OPTI_TYPE_APPENDED_SALT
6957 | OPTI_TYPE_RAW_HASH;
6958 dgst_pos0 = 0;
6959 dgst_pos1 = 3;
6960 dgst_pos2 = 2;
6961 dgst_pos3 = 1;
6962 break;
6963
6964 case 20: hash_type = HASH_TYPE_MD5;
6965 salt_type = SALT_TYPE_INTERN;
6966 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6967 opts_type = OPTS_TYPE_PT_GENERATE_LE
6968 | OPTS_TYPE_PT_ADD80
6969 | OPTS_TYPE_PT_ADDBITS14;
6970 kern_type = KERN_TYPE_MD5_SLTPW;
6971 dgst_size = DGST_SIZE_4_4;
6972 parse_func = md5s_parse_hash;
6973 sort_by_digest = sort_by_digest_4_4;
6974 opti_type = OPTI_TYPE_ZERO_BYTE
6975 | OPTI_TYPE_PRECOMPUTE_INIT
6976 | OPTI_TYPE_PRECOMPUTE_MERKLE
6977 | OPTI_TYPE_EARLY_SKIP
6978 | OPTI_TYPE_NOT_ITERATED
6979 | OPTI_TYPE_PREPENDED_SALT
6980 | OPTI_TYPE_RAW_HASH;
6981 dgst_pos0 = 0;
6982 dgst_pos1 = 3;
6983 dgst_pos2 = 2;
6984 dgst_pos3 = 1;
6985 break;
6986
6987 case 21: hash_type = HASH_TYPE_MD5;
6988 salt_type = SALT_TYPE_INTERN;
6989 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6990 opts_type = OPTS_TYPE_PT_GENERATE_LE
6991 | OPTS_TYPE_PT_ADD80
6992 | OPTS_TYPE_PT_ADDBITS14;
6993 kern_type = KERN_TYPE_MD5_SLTPW;
6994 dgst_size = DGST_SIZE_4_4;
6995 parse_func = osc_parse_hash;
6996 sort_by_digest = sort_by_digest_4_4;
6997 opti_type = OPTI_TYPE_ZERO_BYTE
6998 | OPTI_TYPE_PRECOMPUTE_INIT
6999 | OPTI_TYPE_PRECOMPUTE_MERKLE
7000 | OPTI_TYPE_EARLY_SKIP
7001 | OPTI_TYPE_NOT_ITERATED
7002 | OPTI_TYPE_PREPENDED_SALT
7003 | OPTI_TYPE_RAW_HASH;
7004 dgst_pos0 = 0;
7005 dgst_pos1 = 3;
7006 dgst_pos2 = 2;
7007 dgst_pos3 = 1;
7008 break;
7009
7010 case 22: hash_type = HASH_TYPE_MD5;
7011 salt_type = SALT_TYPE_EMBEDDED;
7012 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7013 opts_type = OPTS_TYPE_PT_GENERATE_LE
7014 | OPTS_TYPE_PT_ADD80
7015 | OPTS_TYPE_PT_ADDBITS14;
7016 kern_type = KERN_TYPE_MD5_SLTPW;
7017 dgst_size = DGST_SIZE_4_4;
7018 parse_func = netscreen_parse_hash;
7019 sort_by_digest = sort_by_digest_4_4;
7020 opti_type = OPTI_TYPE_ZERO_BYTE
7021 | OPTI_TYPE_PRECOMPUTE_INIT
7022 | OPTI_TYPE_PRECOMPUTE_MERKLE
7023 | OPTI_TYPE_EARLY_SKIP
7024 | OPTI_TYPE_NOT_ITERATED
7025 | OPTI_TYPE_PREPENDED_SALT
7026 | OPTI_TYPE_RAW_HASH;
7027 dgst_pos0 = 0;
7028 dgst_pos1 = 3;
7029 dgst_pos2 = 2;
7030 dgst_pos3 = 1;
7031 break;
7032
7033 case 23: hash_type = HASH_TYPE_MD5;
7034 salt_type = SALT_TYPE_EMBEDDED;
7035 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7036 opts_type = OPTS_TYPE_PT_GENERATE_LE
7037 | OPTS_TYPE_PT_ADD80
7038 | OPTS_TYPE_PT_ADDBITS14;
7039 kern_type = KERN_TYPE_MD5_SLTPW;
7040 dgst_size = DGST_SIZE_4_4;
7041 parse_func = skype_parse_hash;
7042 sort_by_digest = sort_by_digest_4_4;
7043 opti_type = OPTI_TYPE_ZERO_BYTE
7044 | OPTI_TYPE_PRECOMPUTE_INIT
7045 | OPTI_TYPE_PRECOMPUTE_MERKLE
7046 | OPTI_TYPE_EARLY_SKIP
7047 | OPTI_TYPE_NOT_ITERATED
7048 | OPTI_TYPE_PREPENDED_SALT
7049 | OPTI_TYPE_RAW_HASH;
7050 dgst_pos0 = 0;
7051 dgst_pos1 = 3;
7052 dgst_pos2 = 2;
7053 dgst_pos3 = 1;
7054 break;
7055
7056 case 30: hash_type = HASH_TYPE_MD5;
7057 salt_type = SALT_TYPE_INTERN;
7058 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7059 opts_type = OPTS_TYPE_PT_GENERATE_LE
7060 | OPTS_TYPE_PT_UNICODE
7061 | OPTS_TYPE_ST_ADD80
7062 | OPTS_TYPE_ST_ADDBITS14;
7063 kern_type = KERN_TYPE_MD5_PWUSLT;
7064 dgst_size = DGST_SIZE_4_4;
7065 parse_func = md5s_parse_hash;
7066 sort_by_digest = sort_by_digest_4_4;
7067 opti_type = OPTI_TYPE_ZERO_BYTE
7068 | OPTI_TYPE_PRECOMPUTE_INIT
7069 | OPTI_TYPE_PRECOMPUTE_MERKLE
7070 | OPTI_TYPE_MEET_IN_MIDDLE
7071 | OPTI_TYPE_EARLY_SKIP
7072 | OPTI_TYPE_NOT_ITERATED
7073 | OPTI_TYPE_APPENDED_SALT
7074 | OPTI_TYPE_RAW_HASH;
7075 dgst_pos0 = 0;
7076 dgst_pos1 = 3;
7077 dgst_pos2 = 2;
7078 dgst_pos3 = 1;
7079 break;
7080
7081 case 40: hash_type = HASH_TYPE_MD5;
7082 salt_type = SALT_TYPE_INTERN;
7083 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7084 opts_type = OPTS_TYPE_PT_GENERATE_LE
7085 | OPTS_TYPE_PT_ADD80
7086 | OPTS_TYPE_PT_ADDBITS14
7087 | OPTS_TYPE_PT_UNICODE;
7088 kern_type = KERN_TYPE_MD5_SLTPWU;
7089 dgst_size = DGST_SIZE_4_4;
7090 parse_func = md5s_parse_hash;
7091 sort_by_digest = sort_by_digest_4_4;
7092 opti_type = OPTI_TYPE_ZERO_BYTE
7093 | OPTI_TYPE_PRECOMPUTE_INIT
7094 | OPTI_TYPE_PRECOMPUTE_MERKLE
7095 | OPTI_TYPE_EARLY_SKIP
7096 | OPTI_TYPE_NOT_ITERATED
7097 | OPTI_TYPE_PREPENDED_SALT
7098 | OPTI_TYPE_RAW_HASH;
7099 dgst_pos0 = 0;
7100 dgst_pos1 = 3;
7101 dgst_pos2 = 2;
7102 dgst_pos3 = 1;
7103 break;
7104
7105 case 50: hash_type = HASH_TYPE_MD5;
7106 salt_type = SALT_TYPE_INTERN;
7107 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7108 opts_type = OPTS_TYPE_PT_GENERATE_LE
7109 | OPTS_TYPE_ST_ADD80
7110 | OPTS_TYPE_ST_ADDBITS14;
7111 kern_type = KERN_TYPE_HMACMD5_PW;
7112 dgst_size = DGST_SIZE_4_4;
7113 parse_func = hmacmd5_parse_hash;
7114 sort_by_digest = sort_by_digest_4_4;
7115 opti_type = OPTI_TYPE_ZERO_BYTE
7116 | OPTI_TYPE_NOT_ITERATED;
7117 dgst_pos0 = 0;
7118 dgst_pos1 = 3;
7119 dgst_pos2 = 2;
7120 dgst_pos3 = 1;
7121 break;
7122
7123 case 60: hash_type = HASH_TYPE_MD5;
7124 salt_type = SALT_TYPE_INTERN;
7125 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7126 opts_type = OPTS_TYPE_PT_GENERATE_LE
7127 | OPTS_TYPE_PT_ADD80
7128 | OPTS_TYPE_PT_ADDBITS14;
7129 kern_type = KERN_TYPE_HMACMD5_SLT;
7130 dgst_size = DGST_SIZE_4_4;
7131 parse_func = hmacmd5_parse_hash;
7132 sort_by_digest = sort_by_digest_4_4;
7133 opti_type = OPTI_TYPE_ZERO_BYTE
7134 | OPTI_TYPE_NOT_ITERATED;
7135 dgst_pos0 = 0;
7136 dgst_pos1 = 3;
7137 dgst_pos2 = 2;
7138 dgst_pos3 = 1;
7139 break;
7140
7141 case 100: hash_type = HASH_TYPE_SHA1;
7142 salt_type = SALT_TYPE_NONE;
7143 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7144 opts_type = OPTS_TYPE_PT_GENERATE_BE
7145 | OPTS_TYPE_PT_ADD80
7146 | OPTS_TYPE_PT_ADDBITS15;
7147 kern_type = KERN_TYPE_SHA1;
7148 dgst_size = DGST_SIZE_4_5;
7149 parse_func = sha1_parse_hash;
7150 sort_by_digest = sort_by_digest_4_5;
7151 opti_type = OPTI_TYPE_ZERO_BYTE
7152 | OPTI_TYPE_PRECOMPUTE_INIT
7153 | OPTI_TYPE_PRECOMPUTE_MERKLE
7154 | OPTI_TYPE_EARLY_SKIP
7155 | OPTI_TYPE_NOT_ITERATED
7156 | OPTI_TYPE_NOT_SALTED
7157 | OPTI_TYPE_RAW_HASH;
7158 dgst_pos0 = 3;
7159 dgst_pos1 = 4;
7160 dgst_pos2 = 2;
7161 dgst_pos3 = 1;
7162 break;
7163
7164 case 101: hash_type = HASH_TYPE_SHA1;
7165 salt_type = SALT_TYPE_NONE;
7166 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7167 opts_type = OPTS_TYPE_PT_GENERATE_BE
7168 | OPTS_TYPE_PT_ADD80
7169 | OPTS_TYPE_PT_ADDBITS15;
7170 kern_type = KERN_TYPE_SHA1;
7171 dgst_size = DGST_SIZE_4_5;
7172 parse_func = sha1b64_parse_hash;
7173 sort_by_digest = sort_by_digest_4_5;
7174 opti_type = OPTI_TYPE_ZERO_BYTE
7175 | OPTI_TYPE_PRECOMPUTE_INIT
7176 | OPTI_TYPE_PRECOMPUTE_MERKLE
7177 | OPTI_TYPE_EARLY_SKIP
7178 | OPTI_TYPE_NOT_ITERATED
7179 | OPTI_TYPE_NOT_SALTED
7180 | OPTI_TYPE_RAW_HASH;
7181 dgst_pos0 = 3;
7182 dgst_pos1 = 4;
7183 dgst_pos2 = 2;
7184 dgst_pos3 = 1;
7185 break;
7186
7187 case 110: hash_type = HASH_TYPE_SHA1;
7188 salt_type = SALT_TYPE_INTERN;
7189 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7190 opts_type = OPTS_TYPE_PT_GENERATE_BE
7191 | OPTS_TYPE_ST_ADD80
7192 | OPTS_TYPE_ST_ADDBITS15;
7193 kern_type = KERN_TYPE_SHA1_PWSLT;
7194 dgst_size = DGST_SIZE_4_5;
7195 parse_func = sha1s_parse_hash;
7196 sort_by_digest = sort_by_digest_4_5;
7197 opti_type = OPTI_TYPE_ZERO_BYTE
7198 | OPTI_TYPE_PRECOMPUTE_INIT
7199 | OPTI_TYPE_PRECOMPUTE_MERKLE
7200 | OPTI_TYPE_EARLY_SKIP
7201 | OPTI_TYPE_NOT_ITERATED
7202 | OPTI_TYPE_APPENDED_SALT
7203 | OPTI_TYPE_RAW_HASH;
7204 dgst_pos0 = 3;
7205 dgst_pos1 = 4;
7206 dgst_pos2 = 2;
7207 dgst_pos3 = 1;
7208 break;
7209
7210 case 111: hash_type = HASH_TYPE_SHA1;
7211 salt_type = SALT_TYPE_EMBEDDED;
7212 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7213 opts_type = OPTS_TYPE_PT_GENERATE_BE
7214 | OPTS_TYPE_ST_ADD80
7215 | OPTS_TYPE_ST_ADDBITS15;
7216 kern_type = KERN_TYPE_SHA1_PWSLT;
7217 dgst_size = DGST_SIZE_4_5;
7218 parse_func = sha1b64s_parse_hash;
7219 sort_by_digest = sort_by_digest_4_5;
7220 opti_type = OPTI_TYPE_ZERO_BYTE
7221 | OPTI_TYPE_PRECOMPUTE_INIT
7222 | OPTI_TYPE_PRECOMPUTE_MERKLE
7223 | OPTI_TYPE_EARLY_SKIP
7224 | OPTI_TYPE_NOT_ITERATED
7225 | OPTI_TYPE_APPENDED_SALT
7226 | OPTI_TYPE_RAW_HASH;
7227 dgst_pos0 = 3;
7228 dgst_pos1 = 4;
7229 dgst_pos2 = 2;
7230 dgst_pos3 = 1;
7231 break;
7232
7233 case 112: hash_type = HASH_TYPE_SHA1;
7234 salt_type = SALT_TYPE_INTERN;
7235 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7236 opts_type = OPTS_TYPE_PT_GENERATE_BE
7237 | OPTS_TYPE_ST_ADD80
7238 | OPTS_TYPE_ST_ADDBITS15
7239 | OPTS_TYPE_ST_HEX;
7240 kern_type = KERN_TYPE_SHA1_PWSLT;
7241 dgst_size = DGST_SIZE_4_5;
7242 parse_func = oracles_parse_hash;
7243 sort_by_digest = sort_by_digest_4_5;
7244 opti_type = OPTI_TYPE_ZERO_BYTE
7245 | OPTI_TYPE_PRECOMPUTE_INIT
7246 | OPTI_TYPE_PRECOMPUTE_MERKLE
7247 | OPTI_TYPE_EARLY_SKIP
7248 | OPTI_TYPE_NOT_ITERATED
7249 | OPTI_TYPE_APPENDED_SALT
7250 | OPTI_TYPE_RAW_HASH;
7251 dgst_pos0 = 3;
7252 dgst_pos1 = 4;
7253 dgst_pos2 = 2;
7254 dgst_pos3 = 1;
7255 break;
7256
7257 case 120: hash_type = HASH_TYPE_SHA1;
7258 salt_type = SALT_TYPE_INTERN;
7259 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7260 opts_type = OPTS_TYPE_PT_GENERATE_BE
7261 | OPTS_TYPE_PT_ADD80
7262 | OPTS_TYPE_PT_ADDBITS15;
7263 kern_type = KERN_TYPE_SHA1_SLTPW;
7264 dgst_size = DGST_SIZE_4_5;
7265 parse_func = sha1s_parse_hash;
7266 sort_by_digest = sort_by_digest_4_5;
7267 opti_type = OPTI_TYPE_ZERO_BYTE
7268 | OPTI_TYPE_PRECOMPUTE_INIT
7269 | OPTI_TYPE_PRECOMPUTE_MERKLE
7270 | OPTI_TYPE_EARLY_SKIP
7271 | OPTI_TYPE_NOT_ITERATED
7272 | OPTI_TYPE_PREPENDED_SALT
7273 | OPTI_TYPE_RAW_HASH;
7274 dgst_pos0 = 3;
7275 dgst_pos1 = 4;
7276 dgst_pos2 = 2;
7277 dgst_pos3 = 1;
7278 break;
7279
7280 case 121: hash_type = HASH_TYPE_SHA1;
7281 salt_type = SALT_TYPE_INTERN;
7282 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7283 opts_type = OPTS_TYPE_PT_GENERATE_BE
7284 | OPTS_TYPE_PT_ADD80
7285 | OPTS_TYPE_PT_ADDBITS15
7286 | OPTS_TYPE_ST_LOWER;
7287 kern_type = KERN_TYPE_SHA1_SLTPW;
7288 dgst_size = DGST_SIZE_4_5;
7289 parse_func = smf_parse_hash;
7290 sort_by_digest = sort_by_digest_4_5;
7291 opti_type = OPTI_TYPE_ZERO_BYTE
7292 | OPTI_TYPE_PRECOMPUTE_INIT
7293 | OPTI_TYPE_PRECOMPUTE_MERKLE
7294 | OPTI_TYPE_EARLY_SKIP
7295 | OPTI_TYPE_NOT_ITERATED
7296 | OPTI_TYPE_PREPENDED_SALT
7297 | OPTI_TYPE_RAW_HASH;
7298 dgst_pos0 = 3;
7299 dgst_pos1 = 4;
7300 dgst_pos2 = 2;
7301 dgst_pos3 = 1;
7302 break;
7303
7304 case 122: hash_type = HASH_TYPE_SHA1;
7305 salt_type = SALT_TYPE_EMBEDDED;
7306 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7307 opts_type = OPTS_TYPE_PT_GENERATE_BE
7308 | OPTS_TYPE_PT_ADD80
7309 | OPTS_TYPE_PT_ADDBITS15
7310 | OPTS_TYPE_ST_HEX;
7311 kern_type = KERN_TYPE_SHA1_SLTPW;
7312 dgst_size = DGST_SIZE_4_5;
7313 parse_func = osx1_parse_hash;
7314 sort_by_digest = sort_by_digest_4_5;
7315 opti_type = OPTI_TYPE_ZERO_BYTE
7316 | OPTI_TYPE_PRECOMPUTE_INIT
7317 | OPTI_TYPE_PRECOMPUTE_MERKLE
7318 | OPTI_TYPE_EARLY_SKIP
7319 | OPTI_TYPE_NOT_ITERATED
7320 | OPTI_TYPE_PREPENDED_SALT
7321 | OPTI_TYPE_RAW_HASH;
7322 dgst_pos0 = 3;
7323 dgst_pos1 = 4;
7324 dgst_pos2 = 2;
7325 dgst_pos3 = 1;
7326 break;
7327
7328 case 124: hash_type = HASH_TYPE_SHA1;
7329 salt_type = SALT_TYPE_EMBEDDED;
7330 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7331 opts_type = OPTS_TYPE_PT_GENERATE_BE
7332 | OPTS_TYPE_PT_ADD80
7333 | OPTS_TYPE_PT_ADDBITS15;
7334 kern_type = KERN_TYPE_SHA1_SLTPW;
7335 dgst_size = DGST_SIZE_4_5;
7336 parse_func = djangosha1_parse_hash;
7337 sort_by_digest = sort_by_digest_4_5;
7338 opti_type = OPTI_TYPE_ZERO_BYTE
7339 | OPTI_TYPE_PRECOMPUTE_INIT
7340 | OPTI_TYPE_PRECOMPUTE_MERKLE
7341 | OPTI_TYPE_EARLY_SKIP
7342 | OPTI_TYPE_NOT_ITERATED
7343 | OPTI_TYPE_PREPENDED_SALT
7344 | OPTI_TYPE_RAW_HASH;
7345 dgst_pos0 = 3;
7346 dgst_pos1 = 4;
7347 dgst_pos2 = 2;
7348 dgst_pos3 = 1;
7349 break;
7350
7351 case 125: hash_type = HASH_TYPE_SHA1;
7352 salt_type = SALT_TYPE_EMBEDDED;
7353 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7354 opts_type = OPTS_TYPE_PT_GENERATE_BE
7355 | OPTS_TYPE_PT_ADD80
7356 | OPTS_TYPE_PT_ADDBITS15
7357 | OPTS_TYPE_ST_HEX;
7358 kern_type = KERN_TYPE_SHA1_SLTPW;
7359 dgst_size = DGST_SIZE_4_5;
7360 parse_func = arubaos_parse_hash;
7361 sort_by_digest = sort_by_digest_4_5;
7362 opti_type = OPTI_TYPE_ZERO_BYTE
7363 | OPTI_TYPE_PRECOMPUTE_INIT
7364 | OPTI_TYPE_PRECOMPUTE_MERKLE
7365 | OPTI_TYPE_EARLY_SKIP
7366 | OPTI_TYPE_NOT_ITERATED
7367 | OPTI_TYPE_PREPENDED_SALT
7368 | OPTI_TYPE_RAW_HASH;
7369 dgst_pos0 = 3;
7370 dgst_pos1 = 4;
7371 dgst_pos2 = 2;
7372 dgst_pos3 = 1;
7373 break;
7374
7375 case 130: hash_type = HASH_TYPE_SHA1;
7376 salt_type = SALT_TYPE_INTERN;
7377 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7378 opts_type = OPTS_TYPE_PT_GENERATE_BE
7379 | OPTS_TYPE_PT_UNICODE
7380 | OPTS_TYPE_ST_ADD80
7381 | OPTS_TYPE_ST_ADDBITS15;
7382 kern_type = KERN_TYPE_SHA1_PWUSLT;
7383 dgst_size = DGST_SIZE_4_5;
7384 parse_func = sha1s_parse_hash;
7385 sort_by_digest = sort_by_digest_4_5;
7386 opti_type = OPTI_TYPE_ZERO_BYTE
7387 | OPTI_TYPE_PRECOMPUTE_INIT
7388 | OPTI_TYPE_PRECOMPUTE_MERKLE
7389 | OPTI_TYPE_EARLY_SKIP
7390 | OPTI_TYPE_NOT_ITERATED
7391 | OPTI_TYPE_APPENDED_SALT
7392 | OPTI_TYPE_RAW_HASH;
7393 dgst_pos0 = 3;
7394 dgst_pos1 = 4;
7395 dgst_pos2 = 2;
7396 dgst_pos3 = 1;
7397 break;
7398
7399 case 131: hash_type = HASH_TYPE_SHA1;
7400 salt_type = SALT_TYPE_EMBEDDED;
7401 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7402 opts_type = OPTS_TYPE_PT_GENERATE_BE
7403 | OPTS_TYPE_PT_UNICODE
7404 | OPTS_TYPE_PT_UPPER
7405 | OPTS_TYPE_ST_ADD80
7406 | OPTS_TYPE_ST_ADDBITS15
7407 | OPTS_TYPE_ST_HEX;
7408 kern_type = KERN_TYPE_SHA1_PWUSLT;
7409 dgst_size = DGST_SIZE_4_5;
7410 parse_func = mssql2000_parse_hash;
7411 sort_by_digest = sort_by_digest_4_5;
7412 opti_type = OPTI_TYPE_ZERO_BYTE
7413 | OPTI_TYPE_PRECOMPUTE_INIT
7414 | OPTI_TYPE_PRECOMPUTE_MERKLE
7415 | OPTI_TYPE_EARLY_SKIP
7416 | OPTI_TYPE_NOT_ITERATED
7417 | OPTI_TYPE_APPENDED_SALT
7418 | OPTI_TYPE_RAW_HASH;
7419 dgst_pos0 = 3;
7420 dgst_pos1 = 4;
7421 dgst_pos2 = 2;
7422 dgst_pos3 = 1;
7423 break;
7424
7425 case 132: hash_type = HASH_TYPE_SHA1;
7426 salt_type = SALT_TYPE_EMBEDDED;
7427 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7428 opts_type = OPTS_TYPE_PT_GENERATE_BE
7429 | OPTS_TYPE_PT_UNICODE
7430 | OPTS_TYPE_ST_ADD80
7431 | OPTS_TYPE_ST_ADDBITS15
7432 | OPTS_TYPE_ST_HEX;
7433 kern_type = KERN_TYPE_SHA1_PWUSLT;
7434 dgst_size = DGST_SIZE_4_5;
7435 parse_func = mssql2005_parse_hash;
7436 sort_by_digest = sort_by_digest_4_5;
7437 opti_type = OPTI_TYPE_ZERO_BYTE
7438 | OPTI_TYPE_PRECOMPUTE_INIT
7439 | OPTI_TYPE_PRECOMPUTE_MERKLE
7440 | OPTI_TYPE_EARLY_SKIP
7441 | OPTI_TYPE_NOT_ITERATED
7442 | OPTI_TYPE_APPENDED_SALT
7443 | OPTI_TYPE_RAW_HASH;
7444 dgst_pos0 = 3;
7445 dgst_pos1 = 4;
7446 dgst_pos2 = 2;
7447 dgst_pos3 = 1;
7448 break;
7449
7450 case 133: hash_type = HASH_TYPE_SHA1;
7451 salt_type = SALT_TYPE_EMBEDDED;
7452 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7453 opts_type = OPTS_TYPE_PT_GENERATE_BE
7454 | OPTS_TYPE_PT_UNICODE
7455 | OPTS_TYPE_ST_ADD80
7456 | OPTS_TYPE_ST_ADDBITS15;
7457 kern_type = KERN_TYPE_SHA1_PWUSLT;
7458 dgst_size = DGST_SIZE_4_5;
7459 parse_func = peoplesoft_parse_hash;
7460 sort_by_digest = sort_by_digest_4_5;
7461 opti_type = OPTI_TYPE_ZERO_BYTE
7462 | OPTI_TYPE_PRECOMPUTE_INIT
7463 | OPTI_TYPE_PRECOMPUTE_MERKLE
7464 | OPTI_TYPE_EARLY_SKIP
7465 | OPTI_TYPE_NOT_ITERATED
7466 | OPTI_TYPE_APPENDED_SALT
7467 | OPTI_TYPE_RAW_HASH;
7468 dgst_pos0 = 3;
7469 dgst_pos1 = 4;
7470 dgst_pos2 = 2;
7471 dgst_pos3 = 1;
7472 break;
7473
7474 case 140: hash_type = HASH_TYPE_SHA1;
7475 salt_type = SALT_TYPE_INTERN;
7476 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7477 opts_type = OPTS_TYPE_PT_GENERATE_BE
7478 | OPTS_TYPE_PT_ADD80
7479 | OPTS_TYPE_PT_ADDBITS15
7480 | OPTS_TYPE_PT_UNICODE;
7481 kern_type = KERN_TYPE_SHA1_SLTPWU;
7482 dgst_size = DGST_SIZE_4_5;
7483 parse_func = sha1s_parse_hash;
7484 sort_by_digest = sort_by_digest_4_5;
7485 opti_type = OPTI_TYPE_ZERO_BYTE
7486 | OPTI_TYPE_PRECOMPUTE_INIT
7487 | OPTI_TYPE_PRECOMPUTE_MERKLE
7488 | OPTI_TYPE_EARLY_SKIP
7489 | OPTI_TYPE_NOT_ITERATED
7490 | OPTI_TYPE_PREPENDED_SALT
7491 | OPTI_TYPE_RAW_HASH;
7492 dgst_pos0 = 3;
7493 dgst_pos1 = 4;
7494 dgst_pos2 = 2;
7495 dgst_pos3 = 1;
7496 break;
7497
7498 case 141: hash_type = HASH_TYPE_SHA1;
7499 salt_type = SALT_TYPE_EMBEDDED;
7500 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7501 opts_type = OPTS_TYPE_PT_GENERATE_BE
7502 | OPTS_TYPE_PT_ADD80
7503 | OPTS_TYPE_PT_ADDBITS15
7504 | OPTS_TYPE_PT_UNICODE
7505 | OPTS_TYPE_ST_BASE64;
7506 kern_type = KERN_TYPE_SHA1_SLTPWU;
7507 dgst_size = DGST_SIZE_4_5;
7508 parse_func = episerver_parse_hash;
7509 sort_by_digest = sort_by_digest_4_5;
7510 opti_type = OPTI_TYPE_ZERO_BYTE
7511 | OPTI_TYPE_PRECOMPUTE_INIT
7512 | OPTI_TYPE_PRECOMPUTE_MERKLE
7513 | OPTI_TYPE_EARLY_SKIP
7514 | OPTI_TYPE_NOT_ITERATED
7515 | OPTI_TYPE_PREPENDED_SALT
7516 | OPTI_TYPE_RAW_HASH;
7517 dgst_pos0 = 3;
7518 dgst_pos1 = 4;
7519 dgst_pos2 = 2;
7520 dgst_pos3 = 1;
7521 break;
7522
7523 case 150: hash_type = HASH_TYPE_SHA1;
7524 salt_type = SALT_TYPE_INTERN;
7525 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7526 opts_type = OPTS_TYPE_PT_GENERATE_BE
7527 | OPTS_TYPE_ST_ADD80
7528 | OPTS_TYPE_ST_ADDBITS15;
7529 kern_type = KERN_TYPE_HMACSHA1_PW;
7530 dgst_size = DGST_SIZE_4_5;
7531 parse_func = hmacsha1_parse_hash;
7532 sort_by_digest = sort_by_digest_4_5;
7533 opti_type = OPTI_TYPE_ZERO_BYTE
7534 | OPTI_TYPE_NOT_ITERATED;
7535 dgst_pos0 = 3;
7536 dgst_pos1 = 4;
7537 dgst_pos2 = 2;
7538 dgst_pos3 = 1;
7539 break;
7540
7541 case 160: hash_type = HASH_TYPE_SHA1;
7542 salt_type = SALT_TYPE_INTERN;
7543 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7544 opts_type = OPTS_TYPE_PT_GENERATE_BE
7545 | OPTS_TYPE_PT_ADD80
7546 | OPTS_TYPE_PT_ADDBITS15;
7547 kern_type = KERN_TYPE_HMACSHA1_SLT;
7548 dgst_size = DGST_SIZE_4_5;
7549 parse_func = hmacsha1_parse_hash;
7550 sort_by_digest = sort_by_digest_4_5;
7551 opti_type = OPTI_TYPE_ZERO_BYTE
7552 | OPTI_TYPE_NOT_ITERATED;
7553 dgst_pos0 = 3;
7554 dgst_pos1 = 4;
7555 dgst_pos2 = 2;
7556 dgst_pos3 = 1;
7557 break;
7558
7559 case 190: hash_type = HASH_TYPE_SHA1;
7560 salt_type = SALT_TYPE_NONE;
7561 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7562 opts_type = OPTS_TYPE_PT_GENERATE_BE
7563 | OPTS_TYPE_PT_ADD80
7564 | OPTS_TYPE_PT_ADDBITS15;
7565 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7566 dgst_size = DGST_SIZE_4_5;
7567 parse_func = sha1linkedin_parse_hash;
7568 sort_by_digest = sort_by_digest_4_5;
7569 opti_type = OPTI_TYPE_ZERO_BYTE
7570 | OPTI_TYPE_PRECOMPUTE_INIT
7571 | OPTI_TYPE_EARLY_SKIP
7572 | OPTI_TYPE_NOT_ITERATED
7573 | OPTI_TYPE_NOT_SALTED;
7574 dgst_pos0 = 0;
7575 dgst_pos1 = 4;
7576 dgst_pos2 = 3;
7577 dgst_pos3 = 2;
7578 break;
7579
7580 case 200: hash_type = HASH_TYPE_MYSQL;
7581 salt_type = SALT_TYPE_NONE;
7582 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7583 opts_type = 0;
7584 kern_type = KERN_TYPE_MYSQL;
7585 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7586 parse_func = mysql323_parse_hash;
7587 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7588 opti_type = OPTI_TYPE_ZERO_BYTE;
7589 dgst_pos0 = 0;
7590 dgst_pos1 = 1;
7591 dgst_pos2 = 2;
7592 dgst_pos3 = 3;
7593 break;
7594
7595 case 300: hash_type = HASH_TYPE_SHA1;
7596 salt_type = SALT_TYPE_NONE;
7597 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7598 opts_type = OPTS_TYPE_PT_GENERATE_BE
7599 | OPTS_TYPE_PT_ADD80
7600 | OPTS_TYPE_PT_ADDBITS15;
7601 kern_type = KERN_TYPE_MYSQL41;
7602 dgst_size = DGST_SIZE_4_5;
7603 parse_func = sha1_parse_hash;
7604 sort_by_digest = sort_by_digest_4_5;
7605 opti_type = OPTI_TYPE_ZERO_BYTE
7606 | OPTI_TYPE_PRECOMPUTE_INIT
7607 | OPTI_TYPE_PRECOMPUTE_MERKLE
7608 | OPTI_TYPE_EARLY_SKIP
7609 | OPTI_TYPE_NOT_ITERATED
7610 | OPTI_TYPE_NOT_SALTED;
7611 dgst_pos0 = 3;
7612 dgst_pos1 = 4;
7613 dgst_pos2 = 2;
7614 dgst_pos3 = 1;
7615 break;
7616
7617 case 400: hash_type = HASH_TYPE_MD5;
7618 salt_type = SALT_TYPE_EMBEDDED;
7619 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7620 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7621 kern_type = KERN_TYPE_PHPASS;
7622 dgst_size = DGST_SIZE_4_4;
7623 parse_func = phpass_parse_hash;
7624 sort_by_digest = sort_by_digest_4_4;
7625 opti_type = OPTI_TYPE_ZERO_BYTE;
7626 dgst_pos0 = 0;
7627 dgst_pos1 = 1;
7628 dgst_pos2 = 2;
7629 dgst_pos3 = 3;
7630 break;
7631
7632 case 500: hash_type = HASH_TYPE_MD5;
7633 salt_type = SALT_TYPE_EMBEDDED;
7634 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7635 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7636 kern_type = KERN_TYPE_MD5CRYPT;
7637 dgst_size = DGST_SIZE_4_4;
7638 parse_func = md5crypt_parse_hash;
7639 sort_by_digest = sort_by_digest_4_4;
7640 opti_type = OPTI_TYPE_ZERO_BYTE;
7641 dgst_pos0 = 0;
7642 dgst_pos1 = 1;
7643 dgst_pos2 = 2;
7644 dgst_pos3 = 3;
7645 break;
7646
7647 case 501: hash_type = HASH_TYPE_MD5;
7648 salt_type = SALT_TYPE_EMBEDDED;
7649 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7650 opts_type = OPTS_TYPE_PT_GENERATE_LE
7651 | OPTS_TYPE_HASH_COPY;
7652 kern_type = KERN_TYPE_MD5CRYPT;
7653 dgst_size = DGST_SIZE_4_4;
7654 parse_func = juniper_parse_hash;
7655 sort_by_digest = sort_by_digest_4_4;
7656 opti_type = OPTI_TYPE_ZERO_BYTE;
7657 dgst_pos0 = 0;
7658 dgst_pos1 = 1;
7659 dgst_pos2 = 2;
7660 dgst_pos3 = 3;
7661 break;
7662
7663 case 900: hash_type = HASH_TYPE_MD4;
7664 salt_type = SALT_TYPE_NONE;
7665 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7666 opts_type = OPTS_TYPE_PT_GENERATE_LE
7667 | OPTS_TYPE_PT_ADD80
7668 | OPTS_TYPE_PT_ADDBITS14;
7669 kern_type = KERN_TYPE_MD4;
7670 dgst_size = DGST_SIZE_4_4;
7671 parse_func = md4_parse_hash;
7672 sort_by_digest = sort_by_digest_4_4;
7673 opti_type = OPTI_TYPE_ZERO_BYTE
7674 | OPTI_TYPE_PRECOMPUTE_INIT
7675 | OPTI_TYPE_PRECOMPUTE_MERKLE
7676 | OPTI_TYPE_MEET_IN_MIDDLE
7677 | OPTI_TYPE_EARLY_SKIP
7678 | OPTI_TYPE_NOT_ITERATED
7679 | OPTI_TYPE_NOT_SALTED
7680 | OPTI_TYPE_RAW_HASH;
7681 dgst_pos0 = 0;
7682 dgst_pos1 = 3;
7683 dgst_pos2 = 2;
7684 dgst_pos3 = 1;
7685 break;
7686
7687 case 1000: hash_type = HASH_TYPE_MD4;
7688 salt_type = SALT_TYPE_NONE;
7689 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7690 opts_type = OPTS_TYPE_PT_GENERATE_LE
7691 | OPTS_TYPE_PT_ADD80
7692 | OPTS_TYPE_PT_ADDBITS14
7693 | OPTS_TYPE_PT_UNICODE;
7694 kern_type = KERN_TYPE_MD4_PWU;
7695 dgst_size = DGST_SIZE_4_4;
7696 parse_func = md4_parse_hash;
7697 sort_by_digest = sort_by_digest_4_4;
7698 opti_type = OPTI_TYPE_ZERO_BYTE
7699 | OPTI_TYPE_PRECOMPUTE_INIT
7700 | OPTI_TYPE_PRECOMPUTE_MERKLE
7701 | OPTI_TYPE_MEET_IN_MIDDLE
7702 | OPTI_TYPE_EARLY_SKIP
7703 | OPTI_TYPE_NOT_ITERATED
7704 | OPTI_TYPE_NOT_SALTED
7705 | OPTI_TYPE_RAW_HASH;
7706 dgst_pos0 = 0;
7707 dgst_pos1 = 3;
7708 dgst_pos2 = 2;
7709 dgst_pos3 = 1;
7710 break;
7711
7712 case 1100: hash_type = HASH_TYPE_MD4;
7713 salt_type = SALT_TYPE_INTERN;
7714 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7715 opts_type = OPTS_TYPE_PT_GENERATE_LE
7716 | OPTS_TYPE_PT_ADD80
7717 | OPTS_TYPE_PT_ADDBITS14
7718 | OPTS_TYPE_PT_UNICODE
7719 | OPTS_TYPE_ST_ADD80
7720 | OPTS_TYPE_ST_UNICODE
7721 | OPTS_TYPE_ST_LOWER;
7722 kern_type = KERN_TYPE_MD44_PWUSLT;
7723 dgst_size = DGST_SIZE_4_4;
7724 parse_func = dcc_parse_hash;
7725 sort_by_digest = sort_by_digest_4_4;
7726 opti_type = OPTI_TYPE_ZERO_BYTE
7727 | OPTI_TYPE_PRECOMPUTE_INIT
7728 | OPTI_TYPE_PRECOMPUTE_MERKLE
7729 | OPTI_TYPE_EARLY_SKIP
7730 | OPTI_TYPE_NOT_ITERATED;
7731 dgst_pos0 = 0;
7732 dgst_pos1 = 3;
7733 dgst_pos2 = 2;
7734 dgst_pos3 = 1;
7735 break;
7736
7737 case 1400: hash_type = HASH_TYPE_SHA256;
7738 salt_type = SALT_TYPE_NONE;
7739 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7740 opts_type = OPTS_TYPE_PT_GENERATE_BE
7741 | OPTS_TYPE_PT_ADD80
7742 | OPTS_TYPE_PT_ADDBITS15;
7743 kern_type = KERN_TYPE_SHA256;
7744 dgst_size = DGST_SIZE_4_8;
7745 parse_func = sha256_parse_hash;
7746 sort_by_digest = sort_by_digest_4_8;
7747 opti_type = OPTI_TYPE_ZERO_BYTE
7748 | OPTI_TYPE_PRECOMPUTE_INIT
7749 | OPTI_TYPE_PRECOMPUTE_MERKLE
7750 | OPTI_TYPE_EARLY_SKIP
7751 | OPTI_TYPE_NOT_ITERATED
7752 | OPTI_TYPE_NOT_SALTED
7753 | OPTI_TYPE_RAW_HASH;
7754 dgst_pos0 = 3;
7755 dgst_pos1 = 7;
7756 dgst_pos2 = 2;
7757 dgst_pos3 = 6;
7758 break;
7759
7760 case 1410: hash_type = HASH_TYPE_SHA256;
7761 salt_type = SALT_TYPE_INTERN;
7762 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7763 opts_type = OPTS_TYPE_PT_GENERATE_BE
7764 | OPTS_TYPE_ST_ADD80
7765 | OPTS_TYPE_ST_ADDBITS15;
7766 kern_type = KERN_TYPE_SHA256_PWSLT;
7767 dgst_size = DGST_SIZE_4_8;
7768 parse_func = sha256s_parse_hash;
7769 sort_by_digest = sort_by_digest_4_8;
7770 opti_type = OPTI_TYPE_ZERO_BYTE
7771 | OPTI_TYPE_PRECOMPUTE_INIT
7772 | OPTI_TYPE_PRECOMPUTE_MERKLE
7773 | OPTI_TYPE_EARLY_SKIP
7774 | OPTI_TYPE_NOT_ITERATED
7775 | OPTI_TYPE_APPENDED_SALT
7776 | OPTI_TYPE_RAW_HASH;
7777 dgst_pos0 = 3;
7778 dgst_pos1 = 7;
7779 dgst_pos2 = 2;
7780 dgst_pos3 = 6;
7781 break;
7782
7783 case 1420: hash_type = HASH_TYPE_SHA256;
7784 salt_type = SALT_TYPE_INTERN;
7785 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7786 opts_type = OPTS_TYPE_PT_GENERATE_BE
7787 | OPTS_TYPE_PT_ADD80
7788 | OPTS_TYPE_PT_ADDBITS15;
7789 kern_type = KERN_TYPE_SHA256_SLTPW;
7790 dgst_size = DGST_SIZE_4_8;
7791 parse_func = sha256s_parse_hash;
7792 sort_by_digest = sort_by_digest_4_8;
7793 opti_type = OPTI_TYPE_ZERO_BYTE
7794 | OPTI_TYPE_PRECOMPUTE_INIT
7795 | OPTI_TYPE_PRECOMPUTE_MERKLE
7796 | OPTI_TYPE_EARLY_SKIP
7797 | OPTI_TYPE_NOT_ITERATED
7798 | OPTI_TYPE_PREPENDED_SALT
7799 | OPTI_TYPE_RAW_HASH;
7800 dgst_pos0 = 3;
7801 dgst_pos1 = 7;
7802 dgst_pos2 = 2;
7803 dgst_pos3 = 6;
7804 break;
7805
7806 case 1421: hash_type = HASH_TYPE_SHA256;
7807 salt_type = SALT_TYPE_EMBEDDED;
7808 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7809 opts_type = OPTS_TYPE_PT_GENERATE_BE
7810 | OPTS_TYPE_PT_ADD80
7811 | OPTS_TYPE_PT_ADDBITS15;
7812 kern_type = KERN_TYPE_SHA256_SLTPW;
7813 dgst_size = DGST_SIZE_4_8;
7814 parse_func = hmailserver_parse_hash;
7815 sort_by_digest = sort_by_digest_4_8;
7816 opti_type = OPTI_TYPE_ZERO_BYTE
7817 | OPTI_TYPE_PRECOMPUTE_INIT
7818 | OPTI_TYPE_PRECOMPUTE_MERKLE
7819 | OPTI_TYPE_EARLY_SKIP
7820 | OPTI_TYPE_NOT_ITERATED
7821 | OPTI_TYPE_PREPENDED_SALT
7822 | OPTI_TYPE_RAW_HASH;
7823 dgst_pos0 = 3;
7824 dgst_pos1 = 7;
7825 dgst_pos2 = 2;
7826 dgst_pos3 = 6;
7827 break;
7828
7829 case 1430: hash_type = HASH_TYPE_SHA256;
7830 salt_type = SALT_TYPE_INTERN;
7831 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7832 opts_type = OPTS_TYPE_PT_GENERATE_BE
7833 | OPTS_TYPE_PT_UNICODE
7834 | OPTS_TYPE_ST_ADD80
7835 | OPTS_TYPE_ST_ADDBITS15;
7836 kern_type = KERN_TYPE_SHA256_PWUSLT;
7837 dgst_size = DGST_SIZE_4_8;
7838 parse_func = sha256s_parse_hash;
7839 sort_by_digest = sort_by_digest_4_8;
7840 opti_type = OPTI_TYPE_ZERO_BYTE
7841 | OPTI_TYPE_PRECOMPUTE_INIT
7842 | OPTI_TYPE_PRECOMPUTE_MERKLE
7843 | OPTI_TYPE_EARLY_SKIP
7844 | OPTI_TYPE_NOT_ITERATED
7845 | OPTI_TYPE_APPENDED_SALT
7846 | OPTI_TYPE_RAW_HASH;
7847 dgst_pos0 = 3;
7848 dgst_pos1 = 7;
7849 dgst_pos2 = 2;
7850 dgst_pos3 = 6;
7851 break;
7852
7853 case 1440: hash_type = HASH_TYPE_SHA256;
7854 salt_type = SALT_TYPE_INTERN;
7855 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7856 opts_type = OPTS_TYPE_PT_GENERATE_BE
7857 | OPTS_TYPE_PT_ADD80
7858 | OPTS_TYPE_PT_ADDBITS15
7859 | OPTS_TYPE_PT_UNICODE;
7860 kern_type = KERN_TYPE_SHA256_SLTPWU;
7861 dgst_size = DGST_SIZE_4_8;
7862 parse_func = sha256s_parse_hash;
7863 sort_by_digest = sort_by_digest_4_8;
7864 opti_type = OPTI_TYPE_ZERO_BYTE
7865 | OPTI_TYPE_PRECOMPUTE_INIT
7866 | OPTI_TYPE_PRECOMPUTE_MERKLE
7867 | OPTI_TYPE_EARLY_SKIP
7868 | OPTI_TYPE_NOT_ITERATED
7869 | OPTI_TYPE_PREPENDED_SALT
7870 | OPTI_TYPE_RAW_HASH;
7871 dgst_pos0 = 3;
7872 dgst_pos1 = 7;
7873 dgst_pos2 = 2;
7874 dgst_pos3 = 6;
7875 break;
7876
7877 case 1441: hash_type = HASH_TYPE_SHA256;
7878 salt_type = SALT_TYPE_EMBEDDED;
7879 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7880 opts_type = OPTS_TYPE_PT_GENERATE_BE
7881 | OPTS_TYPE_PT_ADD80
7882 | OPTS_TYPE_PT_ADDBITS15
7883 | OPTS_TYPE_PT_UNICODE
7884 | OPTS_TYPE_ST_BASE64;
7885 kern_type = KERN_TYPE_SHA256_SLTPWU;
7886 dgst_size = DGST_SIZE_4_8;
7887 parse_func = episerver4_parse_hash;
7888 sort_by_digest = sort_by_digest_4_8;
7889 opti_type = OPTI_TYPE_ZERO_BYTE
7890 | OPTI_TYPE_PRECOMPUTE_INIT
7891 | OPTI_TYPE_PRECOMPUTE_MERKLE
7892 | OPTI_TYPE_EARLY_SKIP
7893 | OPTI_TYPE_NOT_ITERATED
7894 | OPTI_TYPE_PREPENDED_SALT
7895 | OPTI_TYPE_RAW_HASH;
7896 dgst_pos0 = 3;
7897 dgst_pos1 = 7;
7898 dgst_pos2 = 2;
7899 dgst_pos3 = 6;
7900 break;
7901
7902 case 1450: hash_type = HASH_TYPE_SHA256;
7903 salt_type = SALT_TYPE_INTERN;
7904 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7905 opts_type = OPTS_TYPE_PT_GENERATE_BE
7906 | OPTS_TYPE_ST_ADD80;
7907 kern_type = KERN_TYPE_HMACSHA256_PW;
7908 dgst_size = DGST_SIZE_4_8;
7909 parse_func = hmacsha256_parse_hash;
7910 sort_by_digest = sort_by_digest_4_8;
7911 opti_type = OPTI_TYPE_ZERO_BYTE
7912 | OPTI_TYPE_NOT_ITERATED;
7913 dgst_pos0 = 3;
7914 dgst_pos1 = 7;
7915 dgst_pos2 = 2;
7916 dgst_pos3 = 6;
7917 break;
7918
7919 case 1460: hash_type = HASH_TYPE_SHA256;
7920 salt_type = SALT_TYPE_INTERN;
7921 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7922 opts_type = OPTS_TYPE_PT_GENERATE_BE
7923 | OPTS_TYPE_PT_ADD80
7924 | OPTS_TYPE_PT_ADDBITS15;
7925 kern_type = KERN_TYPE_HMACSHA256_SLT;
7926 dgst_size = DGST_SIZE_4_8;
7927 parse_func = hmacsha256_parse_hash;
7928 sort_by_digest = sort_by_digest_4_8;
7929 opti_type = OPTI_TYPE_ZERO_BYTE
7930 | OPTI_TYPE_NOT_ITERATED;
7931 dgst_pos0 = 3;
7932 dgst_pos1 = 7;
7933 dgst_pos2 = 2;
7934 dgst_pos3 = 6;
7935 break;
7936
7937 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7938 salt_type = SALT_TYPE_EMBEDDED;
7939 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7940 opts_type = OPTS_TYPE_PT_GENERATE_LE
7941 | OPTS_TYPE_PT_BITSLICE;
7942 kern_type = KERN_TYPE_DESCRYPT;
7943 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7944 parse_func = descrypt_parse_hash;
7945 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7946 opti_type = OPTI_TYPE_ZERO_BYTE
7947 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7948 dgst_pos0 = 0;
7949 dgst_pos1 = 1;
7950 dgst_pos2 = 2;
7951 dgst_pos3 = 3;
7952 break;
7953
7954 case 1600: hash_type = HASH_TYPE_MD5;
7955 salt_type = SALT_TYPE_EMBEDDED;
7956 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7957 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7958 kern_type = KERN_TYPE_APR1CRYPT;
7959 dgst_size = DGST_SIZE_4_4;
7960 parse_func = md5apr1_parse_hash;
7961 sort_by_digest = sort_by_digest_4_4;
7962 opti_type = OPTI_TYPE_ZERO_BYTE;
7963 dgst_pos0 = 0;
7964 dgst_pos1 = 1;
7965 dgst_pos2 = 2;
7966 dgst_pos3 = 3;
7967 break;
7968
7969 case 1700: hash_type = HASH_TYPE_SHA512;
7970 salt_type = SALT_TYPE_NONE;
7971 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7972 opts_type = OPTS_TYPE_PT_GENERATE_BE
7973 | OPTS_TYPE_PT_ADD80
7974 | OPTS_TYPE_PT_ADDBITS15;
7975 kern_type = KERN_TYPE_SHA512;
7976 dgst_size = DGST_SIZE_8_8;
7977 parse_func = sha512_parse_hash;
7978 sort_by_digest = sort_by_digest_8_8;
7979 opti_type = OPTI_TYPE_ZERO_BYTE
7980 | OPTI_TYPE_PRECOMPUTE_INIT
7981 | OPTI_TYPE_PRECOMPUTE_MERKLE
7982 | OPTI_TYPE_EARLY_SKIP
7983 | OPTI_TYPE_NOT_ITERATED
7984 | OPTI_TYPE_NOT_SALTED
7985 | OPTI_TYPE_USES_BITS_64
7986 | OPTI_TYPE_RAW_HASH;
7987 dgst_pos0 = 14;
7988 dgst_pos1 = 15;
7989 dgst_pos2 = 6;
7990 dgst_pos3 = 7;
7991 break;
7992
7993 case 1710: hash_type = HASH_TYPE_SHA512;
7994 salt_type = SALT_TYPE_INTERN;
7995 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7996 opts_type = OPTS_TYPE_PT_GENERATE_BE
7997 | OPTS_TYPE_ST_ADD80
7998 | OPTS_TYPE_ST_ADDBITS15;
7999 kern_type = KERN_TYPE_SHA512_PWSLT;
8000 dgst_size = DGST_SIZE_8_8;
8001 parse_func = sha512s_parse_hash;
8002 sort_by_digest = sort_by_digest_8_8;
8003 opti_type = OPTI_TYPE_ZERO_BYTE
8004 | OPTI_TYPE_PRECOMPUTE_INIT
8005 | OPTI_TYPE_PRECOMPUTE_MERKLE
8006 | OPTI_TYPE_EARLY_SKIP
8007 | OPTI_TYPE_NOT_ITERATED
8008 | OPTI_TYPE_APPENDED_SALT
8009 | OPTI_TYPE_USES_BITS_64
8010 | OPTI_TYPE_RAW_HASH;
8011 dgst_pos0 = 14;
8012 dgst_pos1 = 15;
8013 dgst_pos2 = 6;
8014 dgst_pos3 = 7;
8015 break;
8016
8017 case 1711: hash_type = HASH_TYPE_SHA512;
8018 salt_type = SALT_TYPE_EMBEDDED;
8019 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8020 opts_type = OPTS_TYPE_PT_GENERATE_BE
8021 | OPTS_TYPE_ST_ADD80
8022 | OPTS_TYPE_ST_ADDBITS15;
8023 kern_type = KERN_TYPE_SHA512_PWSLT;
8024 dgst_size = DGST_SIZE_8_8;
8025 parse_func = sha512b64s_parse_hash;
8026 sort_by_digest = sort_by_digest_8_8;
8027 opti_type = OPTI_TYPE_ZERO_BYTE
8028 | OPTI_TYPE_PRECOMPUTE_INIT
8029 | OPTI_TYPE_PRECOMPUTE_MERKLE
8030 | OPTI_TYPE_EARLY_SKIP
8031 | OPTI_TYPE_NOT_ITERATED
8032 | OPTI_TYPE_APPENDED_SALT
8033 | OPTI_TYPE_USES_BITS_64
8034 | OPTI_TYPE_RAW_HASH;
8035 dgst_pos0 = 14;
8036 dgst_pos1 = 15;
8037 dgst_pos2 = 6;
8038 dgst_pos3 = 7;
8039 break;
8040
8041 case 1720: hash_type = HASH_TYPE_SHA512;
8042 salt_type = SALT_TYPE_INTERN;
8043 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8044 opts_type = OPTS_TYPE_PT_GENERATE_BE
8045 | OPTS_TYPE_PT_ADD80
8046 | OPTS_TYPE_PT_ADDBITS15;
8047 kern_type = KERN_TYPE_SHA512_SLTPW;
8048 dgst_size = DGST_SIZE_8_8;
8049 parse_func = sha512s_parse_hash;
8050 sort_by_digest = sort_by_digest_8_8;
8051 opti_type = OPTI_TYPE_ZERO_BYTE
8052 | OPTI_TYPE_PRECOMPUTE_INIT
8053 | OPTI_TYPE_PRECOMPUTE_MERKLE
8054 | OPTI_TYPE_EARLY_SKIP
8055 | OPTI_TYPE_NOT_ITERATED
8056 | OPTI_TYPE_PREPENDED_SALT
8057 | OPTI_TYPE_USES_BITS_64
8058 | OPTI_TYPE_RAW_HASH;
8059 dgst_pos0 = 14;
8060 dgst_pos1 = 15;
8061 dgst_pos2 = 6;
8062 dgst_pos3 = 7;
8063 break;
8064
8065 case 1722: hash_type = HASH_TYPE_SHA512;
8066 salt_type = SALT_TYPE_EMBEDDED;
8067 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8068 opts_type = OPTS_TYPE_PT_GENERATE_BE
8069 | OPTS_TYPE_PT_ADD80
8070 | OPTS_TYPE_PT_ADDBITS15
8071 | OPTS_TYPE_ST_HEX;
8072 kern_type = KERN_TYPE_SHA512_SLTPW;
8073 dgst_size = DGST_SIZE_8_8;
8074 parse_func = osx512_parse_hash;
8075 sort_by_digest = sort_by_digest_8_8;
8076 opti_type = OPTI_TYPE_ZERO_BYTE
8077 | OPTI_TYPE_PRECOMPUTE_INIT
8078 | OPTI_TYPE_PRECOMPUTE_MERKLE
8079 | OPTI_TYPE_EARLY_SKIP
8080 | OPTI_TYPE_NOT_ITERATED
8081 | OPTI_TYPE_PREPENDED_SALT
8082 | OPTI_TYPE_USES_BITS_64
8083 | OPTI_TYPE_RAW_HASH;
8084 dgst_pos0 = 14;
8085 dgst_pos1 = 15;
8086 dgst_pos2 = 6;
8087 dgst_pos3 = 7;
8088 break;
8089
8090 case 1730: hash_type = HASH_TYPE_SHA512;
8091 salt_type = SALT_TYPE_INTERN;
8092 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8093 opts_type = OPTS_TYPE_PT_GENERATE_BE
8094 | OPTS_TYPE_PT_UNICODE
8095 | OPTS_TYPE_ST_ADD80
8096 | OPTS_TYPE_ST_ADDBITS15;
8097 kern_type = KERN_TYPE_SHA512_PWSLTU;
8098 dgst_size = DGST_SIZE_8_8;
8099 parse_func = sha512s_parse_hash;
8100 sort_by_digest = sort_by_digest_8_8;
8101 opti_type = OPTI_TYPE_ZERO_BYTE
8102 | OPTI_TYPE_PRECOMPUTE_INIT
8103 | OPTI_TYPE_PRECOMPUTE_MERKLE
8104 | OPTI_TYPE_EARLY_SKIP
8105 | OPTI_TYPE_NOT_ITERATED
8106 | OPTI_TYPE_APPENDED_SALT
8107 | OPTI_TYPE_USES_BITS_64
8108 | OPTI_TYPE_RAW_HASH;
8109 dgst_pos0 = 14;
8110 dgst_pos1 = 15;
8111 dgst_pos2 = 6;
8112 dgst_pos3 = 7;
8113 break;
8114
8115 case 1731: hash_type = HASH_TYPE_SHA512;
8116 salt_type = SALT_TYPE_EMBEDDED;
8117 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8118 opts_type = OPTS_TYPE_PT_GENERATE_BE
8119 | OPTS_TYPE_PT_UNICODE
8120 | OPTS_TYPE_ST_ADD80
8121 | OPTS_TYPE_ST_ADDBITS15
8122 | OPTS_TYPE_ST_HEX;
8123 kern_type = KERN_TYPE_SHA512_PWSLTU;
8124 dgst_size = DGST_SIZE_8_8;
8125 parse_func = mssql2012_parse_hash;
8126 sort_by_digest = sort_by_digest_8_8;
8127 opti_type = OPTI_TYPE_ZERO_BYTE
8128 | OPTI_TYPE_PRECOMPUTE_INIT
8129 | OPTI_TYPE_PRECOMPUTE_MERKLE
8130 | OPTI_TYPE_EARLY_SKIP
8131 | OPTI_TYPE_NOT_ITERATED
8132 | OPTI_TYPE_APPENDED_SALT
8133 | OPTI_TYPE_USES_BITS_64
8134 | OPTI_TYPE_RAW_HASH;
8135 dgst_pos0 = 14;
8136 dgst_pos1 = 15;
8137 dgst_pos2 = 6;
8138 dgst_pos3 = 7;
8139 break;
8140
8141 case 1740: hash_type = HASH_TYPE_SHA512;
8142 salt_type = SALT_TYPE_INTERN;
8143 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8144 opts_type = OPTS_TYPE_PT_GENERATE_BE
8145 | OPTS_TYPE_PT_ADD80
8146 | OPTS_TYPE_PT_ADDBITS15
8147 | OPTS_TYPE_PT_UNICODE;
8148 kern_type = KERN_TYPE_SHA512_SLTPWU;
8149 dgst_size = DGST_SIZE_8_8;
8150 parse_func = sha512s_parse_hash;
8151 sort_by_digest = sort_by_digest_8_8;
8152 opti_type = OPTI_TYPE_ZERO_BYTE
8153 | OPTI_TYPE_PRECOMPUTE_INIT
8154 | OPTI_TYPE_PRECOMPUTE_MERKLE
8155 | OPTI_TYPE_EARLY_SKIP
8156 | OPTI_TYPE_NOT_ITERATED
8157 | OPTI_TYPE_PREPENDED_SALT
8158 | OPTI_TYPE_USES_BITS_64
8159 | OPTI_TYPE_RAW_HASH;
8160 dgst_pos0 = 14;
8161 dgst_pos1 = 15;
8162 dgst_pos2 = 6;
8163 dgst_pos3 = 7;
8164 break;
8165
8166 case 1750: hash_type = HASH_TYPE_SHA512;
8167 salt_type = SALT_TYPE_INTERN;
8168 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8169 opts_type = OPTS_TYPE_PT_GENERATE_BE
8170 | OPTS_TYPE_ST_ADD80;
8171 kern_type = KERN_TYPE_HMACSHA512_PW;
8172 dgst_size = DGST_SIZE_8_8;
8173 parse_func = hmacsha512_parse_hash;
8174 sort_by_digest = sort_by_digest_8_8;
8175 opti_type = OPTI_TYPE_ZERO_BYTE
8176 | OPTI_TYPE_USES_BITS_64
8177 | OPTI_TYPE_NOT_ITERATED;
8178 dgst_pos0 = 14;
8179 dgst_pos1 = 15;
8180 dgst_pos2 = 6;
8181 dgst_pos3 = 7;
8182 break;
8183
8184 case 1760: hash_type = HASH_TYPE_SHA512;
8185 salt_type = SALT_TYPE_INTERN;
8186 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8187 opts_type = OPTS_TYPE_PT_GENERATE_BE
8188 | OPTS_TYPE_PT_ADD80
8189 | OPTS_TYPE_PT_ADDBITS15;
8190 kern_type = KERN_TYPE_HMACSHA512_SLT;
8191 dgst_size = DGST_SIZE_8_8;
8192 parse_func = hmacsha512_parse_hash;
8193 sort_by_digest = sort_by_digest_8_8;
8194 opti_type = OPTI_TYPE_ZERO_BYTE
8195 | OPTI_TYPE_USES_BITS_64
8196 | OPTI_TYPE_NOT_ITERATED;
8197 dgst_pos0 = 14;
8198 dgst_pos1 = 15;
8199 dgst_pos2 = 6;
8200 dgst_pos3 = 7;
8201 break;
8202
8203 case 1800: hash_type = HASH_TYPE_SHA512;
8204 salt_type = SALT_TYPE_EMBEDDED;
8205 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8206 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8207 kern_type = KERN_TYPE_SHA512CRYPT;
8208 dgst_size = DGST_SIZE_8_8;
8209 parse_func = sha512crypt_parse_hash;
8210 sort_by_digest = sort_by_digest_8_8;
8211 opti_type = OPTI_TYPE_ZERO_BYTE
8212 | OPTI_TYPE_USES_BITS_64;
8213 dgst_pos0 = 0;
8214 dgst_pos1 = 1;
8215 dgst_pos2 = 2;
8216 dgst_pos3 = 3;
8217 break;
8218
8219 case 2100: hash_type = HASH_TYPE_DCC2;
8220 salt_type = SALT_TYPE_EMBEDDED;
8221 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8222 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8223 | OPTS_TYPE_ST_LOWER
8224 | OPTS_TYPE_ST_UNICODE;
8225 kern_type = KERN_TYPE_DCC2;
8226 dgst_size = DGST_SIZE_4_4;
8227 parse_func = dcc2_parse_hash;
8228 sort_by_digest = sort_by_digest_4_4;
8229 opti_type = OPTI_TYPE_ZERO_BYTE;
8230 dgst_pos0 = 0;
8231 dgst_pos1 = 1;
8232 dgst_pos2 = 2;
8233 dgst_pos3 = 3;
8234 break;
8235
8236 case 2400: hash_type = HASH_TYPE_MD5;
8237 salt_type = SALT_TYPE_NONE;
8238 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8239 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8240 kern_type = KERN_TYPE_MD5PIX;
8241 dgst_size = DGST_SIZE_4_4;
8242 parse_func = md5pix_parse_hash;
8243 sort_by_digest = sort_by_digest_4_4;
8244 opti_type = OPTI_TYPE_ZERO_BYTE
8245 | OPTI_TYPE_PRECOMPUTE_INIT
8246 | OPTI_TYPE_PRECOMPUTE_MERKLE
8247 | OPTI_TYPE_EARLY_SKIP
8248 | OPTI_TYPE_NOT_ITERATED
8249 | OPTI_TYPE_NOT_SALTED;
8250 dgst_pos0 = 0;
8251 dgst_pos1 = 3;
8252 dgst_pos2 = 2;
8253 dgst_pos3 = 1;
8254 break;
8255
8256 case 2410: hash_type = HASH_TYPE_MD5;
8257 salt_type = SALT_TYPE_INTERN;
8258 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8259 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8260 kern_type = KERN_TYPE_MD5ASA;
8261 dgst_size = DGST_SIZE_4_4;
8262 parse_func = md5asa_parse_hash;
8263 sort_by_digest = sort_by_digest_4_4;
8264 opti_type = OPTI_TYPE_ZERO_BYTE
8265 | OPTI_TYPE_PRECOMPUTE_INIT
8266 | OPTI_TYPE_PRECOMPUTE_MERKLE
8267 | OPTI_TYPE_EARLY_SKIP
8268 | OPTI_TYPE_NOT_ITERATED;
8269 dgst_pos0 = 0;
8270 dgst_pos1 = 3;
8271 dgst_pos2 = 2;
8272 dgst_pos3 = 1;
8273 break;
8274
8275 case 2500: hash_type = HASH_TYPE_WPA;
8276 salt_type = SALT_TYPE_EMBEDDED;
8277 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8278 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8279 kern_type = KERN_TYPE_WPA;
8280 dgst_size = DGST_SIZE_4_4;
8281 parse_func = wpa_parse_hash;
8282 sort_by_digest = sort_by_digest_4_4;
8283 opti_type = OPTI_TYPE_ZERO_BYTE;
8284 dgst_pos0 = 0;
8285 dgst_pos1 = 1;
8286 dgst_pos2 = 2;
8287 dgst_pos3 = 3;
8288 break;
8289
8290 case 2600: hash_type = HASH_TYPE_MD5;
8291 salt_type = SALT_TYPE_VIRTUAL;
8292 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8293 opts_type = OPTS_TYPE_PT_GENERATE_LE
8294 | OPTS_TYPE_PT_ADD80
8295 | OPTS_TYPE_PT_ADDBITS14
8296 | OPTS_TYPE_ST_ADD80;
8297 kern_type = KERN_TYPE_MD55_PWSLT1;
8298 dgst_size = DGST_SIZE_4_4;
8299 parse_func = md5md5_parse_hash;
8300 sort_by_digest = sort_by_digest_4_4;
8301 opti_type = OPTI_TYPE_ZERO_BYTE
8302 | OPTI_TYPE_PRECOMPUTE_INIT
8303 | OPTI_TYPE_PRECOMPUTE_MERKLE
8304 | OPTI_TYPE_EARLY_SKIP;
8305 dgst_pos0 = 0;
8306 dgst_pos1 = 3;
8307 dgst_pos2 = 2;
8308 dgst_pos3 = 1;
8309 break;
8310
8311 case 2611: hash_type = HASH_TYPE_MD5;
8312 salt_type = SALT_TYPE_INTERN;
8313 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8314 opts_type = OPTS_TYPE_PT_GENERATE_LE
8315 | OPTS_TYPE_PT_ADD80
8316 | OPTS_TYPE_PT_ADDBITS14
8317 | OPTS_TYPE_ST_ADD80;
8318 kern_type = KERN_TYPE_MD55_PWSLT1;
8319 dgst_size = DGST_SIZE_4_4;
8320 parse_func = vb3_parse_hash;
8321 sort_by_digest = sort_by_digest_4_4;
8322 opti_type = OPTI_TYPE_ZERO_BYTE
8323 | OPTI_TYPE_PRECOMPUTE_INIT
8324 | OPTI_TYPE_PRECOMPUTE_MERKLE
8325 | OPTI_TYPE_EARLY_SKIP;
8326 dgst_pos0 = 0;
8327 dgst_pos1 = 3;
8328 dgst_pos2 = 2;
8329 dgst_pos3 = 1;
8330 break;
8331
8332 case 2612: hash_type = HASH_TYPE_MD5;
8333 salt_type = SALT_TYPE_EMBEDDED;
8334 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8335 opts_type = OPTS_TYPE_PT_GENERATE_LE
8336 | OPTS_TYPE_PT_ADD80
8337 | OPTS_TYPE_PT_ADDBITS14
8338 | OPTS_TYPE_ST_ADD80
8339 | OPTS_TYPE_ST_HEX;
8340 kern_type = KERN_TYPE_MD55_PWSLT1;
8341 dgst_size = DGST_SIZE_4_4;
8342 parse_func = phps_parse_hash;
8343 sort_by_digest = sort_by_digest_4_4;
8344 opti_type = OPTI_TYPE_ZERO_BYTE
8345 | OPTI_TYPE_PRECOMPUTE_INIT
8346 | OPTI_TYPE_PRECOMPUTE_MERKLE
8347 | OPTI_TYPE_EARLY_SKIP;
8348 dgst_pos0 = 0;
8349 dgst_pos1 = 3;
8350 dgst_pos2 = 2;
8351 dgst_pos3 = 1;
8352 break;
8353
8354 case 2711: hash_type = HASH_TYPE_MD5;
8355 salt_type = SALT_TYPE_INTERN;
8356 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8357 opts_type = OPTS_TYPE_PT_GENERATE_LE
8358 | OPTS_TYPE_PT_ADD80
8359 | OPTS_TYPE_PT_ADDBITS14
8360 | OPTS_TYPE_ST_ADD80;
8361 kern_type = KERN_TYPE_MD55_PWSLT2;
8362 dgst_size = DGST_SIZE_4_4;
8363 parse_func = vb30_parse_hash;
8364 sort_by_digest = sort_by_digest_4_4;
8365 opti_type = OPTI_TYPE_ZERO_BYTE
8366 | OPTI_TYPE_PRECOMPUTE_INIT
8367 | OPTI_TYPE_EARLY_SKIP;
8368 dgst_pos0 = 0;
8369 dgst_pos1 = 3;
8370 dgst_pos2 = 2;
8371 dgst_pos3 = 1;
8372 break;
8373
8374 case 2811: hash_type = HASH_TYPE_MD5;
8375 salt_type = SALT_TYPE_INTERN;
8376 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8377 opts_type = OPTS_TYPE_PT_GENERATE_LE
8378 | OPTS_TYPE_PT_ADD80
8379 | OPTS_TYPE_PT_ADDBITS14;
8380 kern_type = KERN_TYPE_MD55_SLTPW;
8381 dgst_size = DGST_SIZE_4_4;
8382 parse_func = ipb2_parse_hash;
8383 sort_by_digest = sort_by_digest_4_4;
8384 opti_type = OPTI_TYPE_ZERO_BYTE
8385 | OPTI_TYPE_PRECOMPUTE_INIT
8386 | OPTI_TYPE_EARLY_SKIP;
8387 dgst_pos0 = 0;
8388 dgst_pos1 = 3;
8389 dgst_pos2 = 2;
8390 dgst_pos3 = 1;
8391 break;
8392
8393 case 3000: hash_type = HASH_TYPE_LM;
8394 salt_type = SALT_TYPE_NONE;
8395 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8396 opts_type = OPTS_TYPE_PT_GENERATE_LE
8397 | OPTS_TYPE_PT_UPPER
8398 | OPTS_TYPE_PT_BITSLICE;
8399 kern_type = KERN_TYPE_LM;
8400 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8401 parse_func = lm_parse_hash;
8402 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8403 opti_type = OPTI_TYPE_ZERO_BYTE
8404 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8405 dgst_pos0 = 0;
8406 dgst_pos1 = 1;
8407 dgst_pos2 = 2;
8408 dgst_pos3 = 3;
8409 break;
8410
8411 case 3100: hash_type = HASH_TYPE_ORACLEH;
8412 salt_type = SALT_TYPE_INTERN;
8413 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8414 opts_type = OPTS_TYPE_PT_GENERATE_LE
8415 | OPTS_TYPE_PT_UPPER
8416 | OPTS_TYPE_ST_UPPER;
8417 kern_type = KERN_TYPE_ORACLEH;
8418 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8419 parse_func = oracleh_parse_hash;
8420 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8421 opti_type = OPTI_TYPE_ZERO_BYTE;
8422 dgst_pos0 = 0;
8423 dgst_pos1 = 1;
8424 dgst_pos2 = 2;
8425 dgst_pos3 = 3;
8426 break;
8427
8428 case 3200: hash_type = HASH_TYPE_BCRYPT;
8429 salt_type = SALT_TYPE_EMBEDDED;
8430 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8431 opts_type = OPTS_TYPE_PT_GENERATE_LE
8432 | OPTS_TYPE_ST_GENERATE_LE;
8433 kern_type = KERN_TYPE_BCRYPT;
8434 dgst_size = DGST_SIZE_4_6;
8435 parse_func = bcrypt_parse_hash;
8436 sort_by_digest = sort_by_digest_4_6;
8437 opti_type = OPTI_TYPE_ZERO_BYTE;
8438 dgst_pos0 = 0;
8439 dgst_pos1 = 1;
8440 dgst_pos2 = 2;
8441 dgst_pos3 = 3;
8442 break;
8443
8444 case 3710: hash_type = HASH_TYPE_MD5;
8445 salt_type = SALT_TYPE_INTERN;
8446 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8447 opts_type = OPTS_TYPE_PT_GENERATE_LE
8448 | OPTS_TYPE_PT_ADD80
8449 | OPTS_TYPE_PT_ADDBITS14;
8450 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8451 dgst_size = DGST_SIZE_4_4;
8452 parse_func = md5s_parse_hash;
8453 sort_by_digest = sort_by_digest_4_4;
8454 opti_type = OPTI_TYPE_ZERO_BYTE
8455 | OPTI_TYPE_PRECOMPUTE_INIT
8456 | OPTI_TYPE_PRECOMPUTE_MERKLE
8457 | OPTI_TYPE_EARLY_SKIP;
8458 dgst_pos0 = 0;
8459 dgst_pos1 = 3;
8460 dgst_pos2 = 2;
8461 dgst_pos3 = 1;
8462 break;
8463
8464 case 3711: hash_type = HASH_TYPE_MD5;
8465 salt_type = SALT_TYPE_EMBEDDED;
8466 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8467 opts_type = OPTS_TYPE_PT_GENERATE_LE
8468 | OPTS_TYPE_PT_ADD80
8469 | OPTS_TYPE_PT_ADDBITS14;
8470 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8471 dgst_size = DGST_SIZE_4_4;
8472 parse_func = mediawiki_b_parse_hash;
8473 sort_by_digest = sort_by_digest_4_4;
8474 opti_type = OPTI_TYPE_ZERO_BYTE
8475 | OPTI_TYPE_PRECOMPUTE_INIT
8476 | OPTI_TYPE_PRECOMPUTE_MERKLE
8477 | OPTI_TYPE_EARLY_SKIP;
8478 dgst_pos0 = 0;
8479 dgst_pos1 = 3;
8480 dgst_pos2 = 2;
8481 dgst_pos3 = 1;
8482 break;
8483
8484 case 3800: hash_type = HASH_TYPE_MD5;
8485 salt_type = SALT_TYPE_INTERN;
8486 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8487 opts_type = OPTS_TYPE_PT_GENERATE_LE
8488 | OPTS_TYPE_ST_ADDBITS14;
8489 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8490 dgst_size = DGST_SIZE_4_4;
8491 parse_func = md5s_parse_hash;
8492 sort_by_digest = sort_by_digest_4_4;
8493 opti_type = OPTI_TYPE_ZERO_BYTE
8494 | OPTI_TYPE_PRECOMPUTE_INIT
8495 | OPTI_TYPE_PRECOMPUTE_MERKLE
8496 | OPTI_TYPE_EARLY_SKIP
8497 | OPTI_TYPE_NOT_ITERATED
8498 | OPTI_TYPE_RAW_HASH;
8499 dgst_pos0 = 0;
8500 dgst_pos1 = 3;
8501 dgst_pos2 = 2;
8502 dgst_pos3 = 1;
8503 break;
8504
8505 case 4300: hash_type = HASH_TYPE_MD5;
8506 salt_type = SALT_TYPE_VIRTUAL;
8507 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8508 opts_type = OPTS_TYPE_PT_GENERATE_LE
8509 | OPTS_TYPE_PT_ADD80
8510 | OPTS_TYPE_PT_ADDBITS14
8511 | OPTS_TYPE_ST_ADD80;
8512 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8513 dgst_size = DGST_SIZE_4_4;
8514 parse_func = md5md5_parse_hash;
8515 sort_by_digest = sort_by_digest_4_4;
8516 opti_type = OPTI_TYPE_ZERO_BYTE
8517 | OPTI_TYPE_PRECOMPUTE_INIT
8518 | OPTI_TYPE_PRECOMPUTE_MERKLE
8519 | OPTI_TYPE_EARLY_SKIP;
8520 dgst_pos0 = 0;
8521 dgst_pos1 = 3;
8522 dgst_pos2 = 2;
8523 dgst_pos3 = 1;
8524 break;
8525
8526
8527 case 4400: hash_type = HASH_TYPE_MD5;
8528 salt_type = SALT_TYPE_NONE;
8529 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8530 opts_type = OPTS_TYPE_PT_GENERATE_BE
8531 | OPTS_TYPE_PT_ADD80
8532 | OPTS_TYPE_PT_ADDBITS15;
8533 kern_type = KERN_TYPE_MD5_SHA1;
8534 dgst_size = DGST_SIZE_4_4;
8535 parse_func = md5_parse_hash;
8536 sort_by_digest = sort_by_digest_4_4;
8537 opti_type = OPTI_TYPE_ZERO_BYTE
8538 | OPTI_TYPE_PRECOMPUTE_INIT
8539 | OPTI_TYPE_PRECOMPUTE_MERKLE
8540 | OPTI_TYPE_EARLY_SKIP
8541 | OPTI_TYPE_NOT_ITERATED
8542 | OPTI_TYPE_NOT_SALTED
8543 | OPTI_TYPE_RAW_HASH;
8544 dgst_pos0 = 0;
8545 dgst_pos1 = 3;
8546 dgst_pos2 = 2;
8547 dgst_pos3 = 1;
8548 break;
8549
8550 case 4500: hash_type = HASH_TYPE_SHA1;
8551 salt_type = SALT_TYPE_NONE;
8552 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8553 opts_type = OPTS_TYPE_PT_GENERATE_BE
8554 | OPTS_TYPE_PT_ADD80
8555 | OPTS_TYPE_PT_ADDBITS15;
8556 kern_type = KERN_TYPE_SHA11;
8557 dgst_size = DGST_SIZE_4_5;
8558 parse_func = sha1_parse_hash;
8559 sort_by_digest = sort_by_digest_4_5;
8560 opti_type = OPTI_TYPE_ZERO_BYTE
8561 | OPTI_TYPE_PRECOMPUTE_INIT
8562 | OPTI_TYPE_PRECOMPUTE_MERKLE
8563 | OPTI_TYPE_EARLY_SKIP
8564 | OPTI_TYPE_NOT_SALTED;
8565 dgst_pos0 = 3;
8566 dgst_pos1 = 4;
8567 dgst_pos2 = 2;
8568 dgst_pos3 = 1;
8569 break;
8570
8571 case 4700: hash_type = HASH_TYPE_SHA1;
8572 salt_type = SALT_TYPE_NONE;
8573 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8574 opts_type = OPTS_TYPE_PT_GENERATE_LE
8575 | OPTS_TYPE_PT_ADD80
8576 | OPTS_TYPE_PT_ADDBITS14;
8577 kern_type = KERN_TYPE_SHA1_MD5;
8578 dgst_size = DGST_SIZE_4_5;
8579 parse_func = sha1_parse_hash;
8580 sort_by_digest = sort_by_digest_4_5;
8581 opti_type = OPTI_TYPE_ZERO_BYTE
8582 | OPTI_TYPE_PRECOMPUTE_INIT
8583 | OPTI_TYPE_PRECOMPUTE_MERKLE
8584 | OPTI_TYPE_EARLY_SKIP
8585 | OPTI_TYPE_NOT_ITERATED
8586 | OPTI_TYPE_NOT_SALTED
8587 | OPTI_TYPE_RAW_HASH;
8588 dgst_pos0 = 3;
8589 dgst_pos1 = 4;
8590 dgst_pos2 = 2;
8591 dgst_pos3 = 1;
8592 break;
8593
8594 case 4800: hash_type = HASH_TYPE_MD5;
8595 salt_type = SALT_TYPE_EMBEDDED;
8596 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8597 opts_type = OPTS_TYPE_PT_GENERATE_LE
8598 | OPTS_TYPE_PT_ADDBITS14;
8599 kern_type = KERN_TYPE_MD5_CHAP;
8600 dgst_size = DGST_SIZE_4_4;
8601 parse_func = chap_parse_hash;
8602 sort_by_digest = sort_by_digest_4_4;
8603 opti_type = OPTI_TYPE_ZERO_BYTE
8604 | OPTI_TYPE_PRECOMPUTE_INIT
8605 | OPTI_TYPE_PRECOMPUTE_MERKLE
8606 | OPTI_TYPE_MEET_IN_MIDDLE
8607 | OPTI_TYPE_EARLY_SKIP
8608 | OPTI_TYPE_NOT_ITERATED
8609 | OPTI_TYPE_RAW_HASH;
8610 dgst_pos0 = 0;
8611 dgst_pos1 = 3;
8612 dgst_pos2 = 2;
8613 dgst_pos3 = 1;
8614 break;
8615
8616 case 4900: hash_type = HASH_TYPE_SHA1;
8617 salt_type = SALT_TYPE_INTERN;
8618 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8619 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8620 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8621 dgst_size = DGST_SIZE_4_5;
8622 parse_func = sha1s_parse_hash;
8623 sort_by_digest = sort_by_digest_4_5;
8624 opti_type = OPTI_TYPE_ZERO_BYTE
8625 | OPTI_TYPE_PRECOMPUTE_INIT
8626 | OPTI_TYPE_PRECOMPUTE_MERKLE
8627 | OPTI_TYPE_EARLY_SKIP;
8628 dgst_pos0 = 3;
8629 dgst_pos1 = 4;
8630 dgst_pos2 = 2;
8631 dgst_pos3 = 1;
8632 break;
8633
8634 case 5000: hash_type = HASH_TYPE_KECCAK;
8635 salt_type = SALT_TYPE_EMBEDDED;
8636 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8637 opts_type = OPTS_TYPE_PT_GENERATE_LE
8638 | OPTS_TYPE_PT_ADD01;
8639 kern_type = KERN_TYPE_KECCAK;
8640 dgst_size = DGST_SIZE_8_25;
8641 parse_func = keccak_parse_hash;
8642 sort_by_digest = sort_by_digest_8_25;
8643 opti_type = OPTI_TYPE_ZERO_BYTE
8644 | OPTI_TYPE_USES_BITS_64
8645 | OPTI_TYPE_RAW_HASH;
8646 dgst_pos0 = 2;
8647 dgst_pos1 = 3;
8648 dgst_pos2 = 4;
8649 dgst_pos3 = 5;
8650 break;
8651
8652 case 5100: hash_type = HASH_TYPE_MD5H;
8653 salt_type = SALT_TYPE_NONE;
8654 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8655 opts_type = OPTS_TYPE_PT_GENERATE_LE
8656 | OPTS_TYPE_PT_ADD80
8657 | OPTS_TYPE_PT_ADDBITS14;
8658 kern_type = KERN_TYPE_MD5H;
8659 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8660 parse_func = md5half_parse_hash;
8661 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8662 opti_type = OPTI_TYPE_ZERO_BYTE
8663 | OPTI_TYPE_RAW_HASH;
8664 dgst_pos0 = 0;
8665 dgst_pos1 = 1;
8666 dgst_pos2 = 2;
8667 dgst_pos3 = 3;
8668 break;
8669
8670 case 5200: hash_type = HASH_TYPE_SHA256;
8671 salt_type = SALT_TYPE_EMBEDDED;
8672 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8673 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8674 kern_type = KERN_TYPE_PSAFE3;
8675 dgst_size = DGST_SIZE_4_8;
8676 parse_func = psafe3_parse_hash;
8677 sort_by_digest = sort_by_digest_4_8;
8678 opti_type = OPTI_TYPE_ZERO_BYTE;
8679 dgst_pos0 = 0;
8680 dgst_pos1 = 1;
8681 dgst_pos2 = 2;
8682 dgst_pos3 = 3;
8683 break;
8684
8685 case 5300: hash_type = HASH_TYPE_MD5;
8686 salt_type = SALT_TYPE_EMBEDDED;
8687 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8688 opts_type = OPTS_TYPE_PT_GENERATE_LE
8689 | OPTS_TYPE_ST_ADD80;
8690 kern_type = KERN_TYPE_IKEPSK_MD5;
8691 dgst_size = DGST_SIZE_4_4;
8692 parse_func = ikepsk_md5_parse_hash;
8693 sort_by_digest = sort_by_digest_4_4;
8694 opti_type = OPTI_TYPE_ZERO_BYTE;
8695 dgst_pos0 = 0;
8696 dgst_pos1 = 3;
8697 dgst_pos2 = 2;
8698 dgst_pos3 = 1;
8699 break;
8700
8701 case 5400: hash_type = HASH_TYPE_SHA1;
8702 salt_type = SALT_TYPE_EMBEDDED;
8703 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8704 opts_type = OPTS_TYPE_PT_GENERATE_BE
8705 | OPTS_TYPE_ST_ADD80;
8706 kern_type = KERN_TYPE_IKEPSK_SHA1;
8707 dgst_size = DGST_SIZE_4_5;
8708 parse_func = ikepsk_sha1_parse_hash;
8709 sort_by_digest = sort_by_digest_4_5;
8710 opti_type = OPTI_TYPE_ZERO_BYTE;
8711 dgst_pos0 = 3;
8712 dgst_pos1 = 4;
8713 dgst_pos2 = 2;
8714 dgst_pos3 = 1;
8715 break;
8716
8717 case 5500: hash_type = HASH_TYPE_NETNTLM;
8718 salt_type = SALT_TYPE_EMBEDDED;
8719 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8720 opts_type = OPTS_TYPE_PT_GENERATE_LE
8721 | OPTS_TYPE_PT_ADD80
8722 | OPTS_TYPE_PT_ADDBITS14
8723 | OPTS_TYPE_PT_UNICODE
8724 | OPTS_TYPE_ST_HEX;
8725 kern_type = KERN_TYPE_NETNTLMv1;
8726 dgst_size = DGST_SIZE_4_4;
8727 parse_func = netntlmv1_parse_hash;
8728 sort_by_digest = sort_by_digest_4_4;
8729 opti_type = OPTI_TYPE_ZERO_BYTE
8730 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8731 dgst_pos0 = 0;
8732 dgst_pos1 = 1;
8733 dgst_pos2 = 2;
8734 dgst_pos3 = 3;
8735 break;
8736
8737 case 5600: hash_type = HASH_TYPE_MD5;
8738 salt_type = SALT_TYPE_EMBEDDED;
8739 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8740 opts_type = OPTS_TYPE_PT_GENERATE_LE
8741 | OPTS_TYPE_PT_ADD80
8742 | OPTS_TYPE_PT_ADDBITS14
8743 | OPTS_TYPE_PT_UNICODE;
8744 kern_type = KERN_TYPE_NETNTLMv2;
8745 dgst_size = DGST_SIZE_4_4;
8746 parse_func = netntlmv2_parse_hash;
8747 sort_by_digest = sort_by_digest_4_4;
8748 opti_type = OPTI_TYPE_ZERO_BYTE;
8749 dgst_pos0 = 0;
8750 dgst_pos1 = 3;
8751 dgst_pos2 = 2;
8752 dgst_pos3 = 1;
8753 break;
8754
8755 case 5700: hash_type = HASH_TYPE_SHA256;
8756 salt_type = SALT_TYPE_NONE;
8757 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8758 opts_type = OPTS_TYPE_PT_GENERATE_BE
8759 | OPTS_TYPE_PT_ADD80
8760 | OPTS_TYPE_PT_ADDBITS15;
8761 kern_type = KERN_TYPE_SHA256;
8762 dgst_size = DGST_SIZE_4_8;
8763 parse_func = cisco4_parse_hash;
8764 sort_by_digest = sort_by_digest_4_8;
8765 opti_type = OPTI_TYPE_ZERO_BYTE
8766 | OPTI_TYPE_PRECOMPUTE_INIT
8767 | OPTI_TYPE_PRECOMPUTE_MERKLE
8768 | OPTI_TYPE_EARLY_SKIP
8769 | OPTI_TYPE_NOT_ITERATED
8770 | OPTI_TYPE_NOT_SALTED
8771 | OPTI_TYPE_RAW_HASH;
8772 dgst_pos0 = 3;
8773 dgst_pos1 = 7;
8774 dgst_pos2 = 2;
8775 dgst_pos3 = 6;
8776 break;
8777
8778 case 5800: hash_type = HASH_TYPE_SHA1;
8779 salt_type = SALT_TYPE_INTERN;
8780 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8781 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8782 | OPTS_TYPE_ST_ADD80;
8783 kern_type = KERN_TYPE_ANDROIDPIN;
8784 dgst_size = DGST_SIZE_4_5;
8785 parse_func = androidpin_parse_hash;
8786 sort_by_digest = sort_by_digest_4_5;
8787 opti_type = OPTI_TYPE_ZERO_BYTE;
8788 dgst_pos0 = 0;
8789 dgst_pos1 = 1;
8790 dgst_pos2 = 2;
8791 dgst_pos3 = 3;
8792 break;
8793
8794 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8795 salt_type = SALT_TYPE_NONE;
8796 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8797 opts_type = OPTS_TYPE_PT_GENERATE_LE
8798 | OPTS_TYPE_PT_ADD80;
8799 kern_type = KERN_TYPE_RIPEMD160;
8800 dgst_size = DGST_SIZE_4_5;
8801 parse_func = ripemd160_parse_hash;
8802 sort_by_digest = sort_by_digest_4_5;
8803 opti_type = OPTI_TYPE_ZERO_BYTE;
8804 dgst_pos0 = 0;
8805 dgst_pos1 = 1;
8806 dgst_pos2 = 2;
8807 dgst_pos3 = 3;
8808 break;
8809
8810 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8811 salt_type = SALT_TYPE_NONE;
8812 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8813 opts_type = OPTS_TYPE_PT_GENERATE_BE
8814 | OPTS_TYPE_PT_ADD80;
8815 kern_type = KERN_TYPE_WHIRLPOOL;
8816 dgst_size = DGST_SIZE_4_16;
8817 parse_func = whirlpool_parse_hash;
8818 sort_by_digest = sort_by_digest_4_16;
8819 opti_type = OPTI_TYPE_ZERO_BYTE;
8820 dgst_pos0 = 0;
8821 dgst_pos1 = 1;
8822 dgst_pos2 = 2;
8823 dgst_pos3 = 3;
8824 break;
8825
8826 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8827 salt_type = SALT_TYPE_EMBEDDED;
8828 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8829 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8830 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8831 dgst_size = DGST_SIZE_4_5;
8832 parse_func = truecrypt_parse_hash_2k;
8833 sort_by_digest = sort_by_digest_4_5;
8834 opti_type = OPTI_TYPE_ZERO_BYTE;
8835 dgst_pos0 = 0;
8836 dgst_pos1 = 1;
8837 dgst_pos2 = 2;
8838 dgst_pos3 = 3;
8839 break;
8840
8841 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8842 salt_type = SALT_TYPE_EMBEDDED;
8843 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8844 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8845 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8846 dgst_size = DGST_SIZE_4_5;
8847 parse_func = truecrypt_parse_hash_2k;
8848 sort_by_digest = sort_by_digest_4_5;
8849 opti_type = OPTI_TYPE_ZERO_BYTE;
8850 dgst_pos0 = 0;
8851 dgst_pos1 = 1;
8852 dgst_pos2 = 2;
8853 dgst_pos3 = 3;
8854 break;
8855
8856 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8857 salt_type = SALT_TYPE_EMBEDDED;
8858 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8859 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8860 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8861 dgst_size = DGST_SIZE_4_5;
8862 parse_func = truecrypt_parse_hash_2k;
8863 sort_by_digest = sort_by_digest_4_5;
8864 opti_type = OPTI_TYPE_ZERO_BYTE;
8865 dgst_pos0 = 0;
8866 dgst_pos1 = 1;
8867 dgst_pos2 = 2;
8868 dgst_pos3 = 3;
8869 break;
8870
8871 case 6221: hash_type = HASH_TYPE_SHA512;
8872 salt_type = SALT_TYPE_EMBEDDED;
8873 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8874 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8875 kern_type = KERN_TYPE_TCSHA512_XTS512;
8876 dgst_size = DGST_SIZE_8_8;
8877 parse_func = truecrypt_parse_hash_1k;
8878 sort_by_digest = sort_by_digest_8_8;
8879 opti_type = OPTI_TYPE_ZERO_BYTE
8880 | OPTI_TYPE_USES_BITS_64;
8881 dgst_pos0 = 0;
8882 dgst_pos1 = 1;
8883 dgst_pos2 = 2;
8884 dgst_pos3 = 3;
8885 break;
8886
8887 case 6222: hash_type = HASH_TYPE_SHA512;
8888 salt_type = SALT_TYPE_EMBEDDED;
8889 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8890 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8891 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8892 dgst_size = DGST_SIZE_8_8;
8893 parse_func = truecrypt_parse_hash_1k;
8894 sort_by_digest = sort_by_digest_8_8;
8895 opti_type = OPTI_TYPE_ZERO_BYTE
8896 | OPTI_TYPE_USES_BITS_64;
8897 dgst_pos0 = 0;
8898 dgst_pos1 = 1;
8899 dgst_pos2 = 2;
8900 dgst_pos3 = 3;
8901 break;
8902
8903 case 6223: hash_type = HASH_TYPE_SHA512;
8904 salt_type = SALT_TYPE_EMBEDDED;
8905 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8906 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8907 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8908 dgst_size = DGST_SIZE_8_8;
8909 parse_func = truecrypt_parse_hash_1k;
8910 sort_by_digest = sort_by_digest_8_8;
8911 opti_type = OPTI_TYPE_ZERO_BYTE
8912 | OPTI_TYPE_USES_BITS_64;
8913 dgst_pos0 = 0;
8914 dgst_pos1 = 1;
8915 dgst_pos2 = 2;
8916 dgst_pos3 = 3;
8917 break;
8918
8919 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8920 salt_type = SALT_TYPE_EMBEDDED;
8921 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8922 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8923 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8924 dgst_size = DGST_SIZE_4_8;
8925 parse_func = truecrypt_parse_hash_1k;
8926 sort_by_digest = sort_by_digest_4_8;
8927 opti_type = OPTI_TYPE_ZERO_BYTE;
8928 dgst_pos0 = 0;
8929 dgst_pos1 = 1;
8930 dgst_pos2 = 2;
8931 dgst_pos3 = 3;
8932 break;
8933
8934 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8935 salt_type = SALT_TYPE_EMBEDDED;
8936 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8937 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8938 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8939 dgst_size = DGST_SIZE_4_8;
8940 parse_func = truecrypt_parse_hash_1k;
8941 sort_by_digest = sort_by_digest_4_8;
8942 opti_type = OPTI_TYPE_ZERO_BYTE;
8943 dgst_pos0 = 0;
8944 dgst_pos1 = 1;
8945 dgst_pos2 = 2;
8946 dgst_pos3 = 3;
8947 break;
8948
8949 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8950 salt_type = SALT_TYPE_EMBEDDED;
8951 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8952 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8953 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8954 dgst_size = DGST_SIZE_4_8;
8955 parse_func = truecrypt_parse_hash_1k;
8956 sort_by_digest = sort_by_digest_4_8;
8957 opti_type = OPTI_TYPE_ZERO_BYTE;
8958 dgst_pos0 = 0;
8959 dgst_pos1 = 1;
8960 dgst_pos2 = 2;
8961 dgst_pos3 = 3;
8962 break;
8963
8964 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8965 salt_type = SALT_TYPE_EMBEDDED;
8966 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8967 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8968 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8969 dgst_size = DGST_SIZE_4_5;
8970 parse_func = truecrypt_parse_hash_1k;
8971 sort_by_digest = sort_by_digest_4_5;
8972 opti_type = OPTI_TYPE_ZERO_BYTE;
8973 dgst_pos0 = 0;
8974 dgst_pos1 = 1;
8975 dgst_pos2 = 2;
8976 dgst_pos3 = 3;
8977 break;
8978
8979 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8980 salt_type = SALT_TYPE_EMBEDDED;
8981 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8982 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8983 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8984 dgst_size = DGST_SIZE_4_5;
8985 parse_func = truecrypt_parse_hash_1k;
8986 sort_by_digest = sort_by_digest_4_5;
8987 opti_type = OPTI_TYPE_ZERO_BYTE;
8988 dgst_pos0 = 0;
8989 dgst_pos1 = 1;
8990 dgst_pos2 = 2;
8991 dgst_pos3 = 3;
8992 break;
8993
8994 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8995 salt_type = SALT_TYPE_EMBEDDED;
8996 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8997 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8998 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8999 dgst_size = DGST_SIZE_4_5;
9000 parse_func = truecrypt_parse_hash_1k;
9001 sort_by_digest = sort_by_digest_4_5;
9002 opti_type = OPTI_TYPE_ZERO_BYTE;
9003 dgst_pos0 = 0;
9004 dgst_pos1 = 1;
9005 dgst_pos2 = 2;
9006 dgst_pos3 = 3;
9007 break;
9008
9009 case 6300: hash_type = HASH_TYPE_MD5;
9010 salt_type = SALT_TYPE_EMBEDDED;
9011 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9012 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9013 kern_type = KERN_TYPE_MD5AIX;
9014 dgst_size = DGST_SIZE_4_4;
9015 parse_func = md5aix_parse_hash;
9016 sort_by_digest = sort_by_digest_4_4;
9017 opti_type = OPTI_TYPE_ZERO_BYTE;
9018 dgst_pos0 = 0;
9019 dgst_pos1 = 1;
9020 dgst_pos2 = 2;
9021 dgst_pos3 = 3;
9022 break;
9023
9024 case 6400: hash_type = HASH_TYPE_SHA256;
9025 salt_type = SALT_TYPE_EMBEDDED;
9026 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9027 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9028 kern_type = KERN_TYPE_SHA256AIX;
9029 dgst_size = DGST_SIZE_4_8;
9030 parse_func = sha256aix_parse_hash;
9031 sort_by_digest = sort_by_digest_4_8;
9032 opti_type = OPTI_TYPE_ZERO_BYTE;
9033 dgst_pos0 = 0;
9034 dgst_pos1 = 1;
9035 dgst_pos2 = 2;
9036 dgst_pos3 = 3;
9037 break;
9038
9039 case 6500: hash_type = HASH_TYPE_SHA512;
9040 salt_type = SALT_TYPE_EMBEDDED;
9041 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9042 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9043 kern_type = KERN_TYPE_SHA512AIX;
9044 dgst_size = DGST_SIZE_8_8;
9045 parse_func = sha512aix_parse_hash;
9046 sort_by_digest = sort_by_digest_8_8;
9047 opti_type = OPTI_TYPE_ZERO_BYTE
9048 | OPTI_TYPE_USES_BITS_64;
9049 dgst_pos0 = 0;
9050 dgst_pos1 = 1;
9051 dgst_pos2 = 2;
9052 dgst_pos3 = 3;
9053 break;
9054
9055 case 6600: hash_type = HASH_TYPE_AES;
9056 salt_type = SALT_TYPE_EMBEDDED;
9057 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9058 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9059 kern_type = KERN_TYPE_AGILEKEY;
9060 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9061 parse_func = agilekey_parse_hash;
9062 sort_by_digest = sort_by_digest_4_5;
9063 opti_type = OPTI_TYPE_ZERO_BYTE;
9064 dgst_pos0 = 0;
9065 dgst_pos1 = 1;
9066 dgst_pos2 = 2;
9067 dgst_pos3 = 3;
9068 break;
9069
9070 case 6700: hash_type = HASH_TYPE_SHA1;
9071 salt_type = SALT_TYPE_EMBEDDED;
9072 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9073 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9074 kern_type = KERN_TYPE_SHA1AIX;
9075 dgst_size = DGST_SIZE_4_5;
9076 parse_func = sha1aix_parse_hash;
9077 sort_by_digest = sort_by_digest_4_5;
9078 opti_type = OPTI_TYPE_ZERO_BYTE;
9079 dgst_pos0 = 0;
9080 dgst_pos1 = 1;
9081 dgst_pos2 = 2;
9082 dgst_pos3 = 3;
9083 break;
9084
9085 case 6800: hash_type = HASH_TYPE_AES;
9086 salt_type = SALT_TYPE_EMBEDDED;
9087 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9088 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9089 kern_type = KERN_TYPE_LASTPASS;
9090 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9091 parse_func = lastpass_parse_hash;
9092 sort_by_digest = sort_by_digest_4_8;
9093 opti_type = OPTI_TYPE_ZERO_BYTE;
9094 dgst_pos0 = 0;
9095 dgst_pos1 = 1;
9096 dgst_pos2 = 2;
9097 dgst_pos3 = 3;
9098 break;
9099
9100 case 6900: hash_type = HASH_TYPE_GOST;
9101 salt_type = SALT_TYPE_NONE;
9102 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9103 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9104 kern_type = KERN_TYPE_GOST;
9105 dgst_size = DGST_SIZE_4_8;
9106 parse_func = gost_parse_hash;
9107 sort_by_digest = sort_by_digest_4_8;
9108 opti_type = OPTI_TYPE_ZERO_BYTE;
9109 dgst_pos0 = 0;
9110 dgst_pos1 = 1;
9111 dgst_pos2 = 2;
9112 dgst_pos3 = 3;
9113 break;
9114
9115 case 7100: hash_type = HASH_TYPE_SHA512;
9116 salt_type = SALT_TYPE_EMBEDDED;
9117 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9118 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9119 kern_type = KERN_TYPE_PBKDF2_SHA512;
9120 dgst_size = DGST_SIZE_8_16;
9121 parse_func = sha512osx_parse_hash;
9122 sort_by_digest = sort_by_digest_8_16;
9123 opti_type = OPTI_TYPE_ZERO_BYTE
9124 | OPTI_TYPE_USES_BITS_64;
9125 dgst_pos0 = 0;
9126 dgst_pos1 = 1;
9127 dgst_pos2 = 2;
9128 dgst_pos3 = 3;
9129 break;
9130
9131 case 7200: hash_type = HASH_TYPE_SHA512;
9132 salt_type = SALT_TYPE_EMBEDDED;
9133 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9134 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9135 kern_type = KERN_TYPE_PBKDF2_SHA512;
9136 dgst_size = DGST_SIZE_8_16;
9137 parse_func = sha512grub_parse_hash;
9138 sort_by_digest = sort_by_digest_8_16;
9139 opti_type = OPTI_TYPE_ZERO_BYTE
9140 | OPTI_TYPE_USES_BITS_64;
9141 dgst_pos0 = 0;
9142 dgst_pos1 = 1;
9143 dgst_pos2 = 2;
9144 dgst_pos3 = 3;
9145 break;
9146
9147 case 7300: hash_type = HASH_TYPE_SHA1;
9148 salt_type = SALT_TYPE_EMBEDDED;
9149 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9150 opts_type = OPTS_TYPE_PT_GENERATE_BE
9151 | OPTS_TYPE_ST_ADD80
9152 | OPTS_TYPE_ST_ADDBITS15;
9153 kern_type = KERN_TYPE_RAKP;
9154 dgst_size = DGST_SIZE_4_5;
9155 parse_func = rakp_parse_hash;
9156 sort_by_digest = sort_by_digest_4_5;
9157 opti_type = OPTI_TYPE_ZERO_BYTE
9158 | OPTI_TYPE_NOT_ITERATED;
9159 dgst_pos0 = 3;
9160 dgst_pos1 = 4;
9161 dgst_pos2 = 2;
9162 dgst_pos3 = 1;
9163 break;
9164
9165 case 7400: hash_type = HASH_TYPE_SHA256;
9166 salt_type = SALT_TYPE_EMBEDDED;
9167 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9168 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9169 kern_type = KERN_TYPE_SHA256CRYPT;
9170 dgst_size = DGST_SIZE_4_8;
9171 parse_func = sha256crypt_parse_hash;
9172 sort_by_digest = sort_by_digest_4_8;
9173 opti_type = OPTI_TYPE_ZERO_BYTE;
9174 dgst_pos0 = 0;
9175 dgst_pos1 = 1;
9176 dgst_pos2 = 2;
9177 dgst_pos3 = 3;
9178 break;
9179
9180 case 7500: hash_type = HASH_TYPE_KRB5PA;
9181 salt_type = SALT_TYPE_EMBEDDED;
9182 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9183 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9184 kern_type = KERN_TYPE_KRB5PA;
9185 dgst_size = DGST_SIZE_4_4;
9186 parse_func = krb5pa_parse_hash;
9187 sort_by_digest = sort_by_digest_4_4;
9188 opti_type = OPTI_TYPE_ZERO_BYTE
9189 | OPTI_TYPE_NOT_ITERATED;
9190 dgst_pos0 = 0;
9191 dgst_pos1 = 1;
9192 dgst_pos2 = 2;
9193 dgst_pos3 = 3;
9194 break;
9195
9196 case 7600: hash_type = HASH_TYPE_SHA1;
9197 salt_type = SALT_TYPE_INTERN;
9198 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9199 opts_type = OPTS_TYPE_PT_GENERATE_BE
9200 | OPTS_TYPE_PT_ADD80
9201 | OPTS_TYPE_PT_ADDBITS15;
9202 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9203 dgst_size = DGST_SIZE_4_5;
9204 parse_func = redmine_parse_hash;
9205 sort_by_digest = sort_by_digest_4_5;
9206 opti_type = OPTI_TYPE_ZERO_BYTE
9207 | OPTI_TYPE_PRECOMPUTE_INIT
9208 | OPTI_TYPE_EARLY_SKIP
9209 | OPTI_TYPE_NOT_ITERATED
9210 | OPTI_TYPE_PREPENDED_SALT;
9211 dgst_pos0 = 3;
9212 dgst_pos1 = 4;
9213 dgst_pos2 = 2;
9214 dgst_pos3 = 1;
9215 break;
9216
9217 case 7700: hash_type = HASH_TYPE_SAPB;
9218 salt_type = SALT_TYPE_EMBEDDED;
9219 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9220 opts_type = OPTS_TYPE_PT_GENERATE_LE
9221 | OPTS_TYPE_PT_UPPER
9222 | OPTS_TYPE_ST_UPPER;
9223 kern_type = KERN_TYPE_SAPB;
9224 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9225 parse_func = sapb_parse_hash;
9226 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9227 opti_type = OPTI_TYPE_ZERO_BYTE
9228 | OPTI_TYPE_PRECOMPUTE_INIT
9229 | OPTI_TYPE_NOT_ITERATED;
9230 dgst_pos0 = 0;
9231 dgst_pos1 = 1;
9232 dgst_pos2 = 2;
9233 dgst_pos3 = 3;
9234 break;
9235
9236 case 7800: hash_type = HASH_TYPE_SAPG;
9237 salt_type = SALT_TYPE_EMBEDDED;
9238 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9239 opts_type = OPTS_TYPE_PT_GENERATE_BE
9240 | OPTS_TYPE_ST_ADD80
9241 | OPTS_TYPE_ST_UPPER;
9242 kern_type = KERN_TYPE_SAPG;
9243 dgst_size = DGST_SIZE_4_5;
9244 parse_func = sapg_parse_hash;
9245 sort_by_digest = sort_by_digest_4_5;
9246 opti_type = OPTI_TYPE_ZERO_BYTE
9247 | OPTI_TYPE_PRECOMPUTE_INIT
9248 | OPTI_TYPE_NOT_ITERATED;
9249 dgst_pos0 = 3;
9250 dgst_pos1 = 4;
9251 dgst_pos2 = 2;
9252 dgst_pos3 = 1;
9253 break;
9254
9255 case 7900: hash_type = HASH_TYPE_SHA512;
9256 salt_type = SALT_TYPE_EMBEDDED;
9257 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9258 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9259 kern_type = KERN_TYPE_DRUPAL7;
9260 dgst_size = DGST_SIZE_8_8;
9261 parse_func = drupal7_parse_hash;
9262 sort_by_digest = sort_by_digest_8_8;
9263 opti_type = OPTI_TYPE_ZERO_BYTE
9264 | OPTI_TYPE_USES_BITS_64;
9265 dgst_pos0 = 0;
9266 dgst_pos1 = 1;
9267 dgst_pos2 = 2;
9268 dgst_pos3 = 3;
9269 break;
9270
9271 case 8000: hash_type = HASH_TYPE_SHA256;
9272 salt_type = SALT_TYPE_EMBEDDED;
9273 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9274 opts_type = OPTS_TYPE_PT_GENERATE_BE
9275 | OPTS_TYPE_PT_UNICODE
9276 | OPTS_TYPE_ST_ADD80
9277 | OPTS_TYPE_ST_HEX;
9278 kern_type = KERN_TYPE_SYBASEASE;
9279 dgst_size = DGST_SIZE_4_8;
9280 parse_func = sybasease_parse_hash;
9281 sort_by_digest = sort_by_digest_4_8;
9282 opti_type = OPTI_TYPE_ZERO_BYTE
9283 | OPTI_TYPE_PRECOMPUTE_INIT
9284 | OPTI_TYPE_EARLY_SKIP
9285 | OPTI_TYPE_NOT_ITERATED
9286 | OPTI_TYPE_RAW_HASH;
9287 dgst_pos0 = 3;
9288 dgst_pos1 = 7;
9289 dgst_pos2 = 2;
9290 dgst_pos3 = 6;
9291 break;
9292
9293 case 8100: hash_type = HASH_TYPE_SHA1;
9294 salt_type = SALT_TYPE_EMBEDDED;
9295 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9296 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9297 kern_type = KERN_TYPE_NETSCALER;
9298 dgst_size = DGST_SIZE_4_5;
9299 parse_func = netscaler_parse_hash;
9300 sort_by_digest = sort_by_digest_4_5;
9301 opti_type = OPTI_TYPE_ZERO_BYTE
9302 | OPTI_TYPE_PRECOMPUTE_INIT
9303 | OPTI_TYPE_PRECOMPUTE_MERKLE
9304 | OPTI_TYPE_EARLY_SKIP
9305 | OPTI_TYPE_NOT_ITERATED
9306 | OPTI_TYPE_PREPENDED_SALT
9307 | OPTI_TYPE_RAW_HASH;
9308 dgst_pos0 = 3;
9309 dgst_pos1 = 4;
9310 dgst_pos2 = 2;
9311 dgst_pos3 = 1;
9312 break;
9313
9314 case 8200: hash_type = HASH_TYPE_SHA256;
9315 salt_type = SALT_TYPE_EMBEDDED;
9316 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9317 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9318 kern_type = KERN_TYPE_CLOUDKEY;
9319 dgst_size = DGST_SIZE_4_8;
9320 parse_func = cloudkey_parse_hash;
9321 sort_by_digest = sort_by_digest_4_8;
9322 opti_type = OPTI_TYPE_ZERO_BYTE;
9323 dgst_pos0 = 0;
9324 dgst_pos1 = 1;
9325 dgst_pos2 = 2;
9326 dgst_pos3 = 3;
9327 break;
9328
9329 case 8300: hash_type = HASH_TYPE_SHA1;
9330 salt_type = SALT_TYPE_EMBEDDED;
9331 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9332 opts_type = OPTS_TYPE_PT_GENERATE_LE
9333 | OPTS_TYPE_ST_HEX
9334 | OPTS_TYPE_ST_ADD80;
9335 kern_type = KERN_TYPE_NSEC3;
9336 dgst_size = DGST_SIZE_4_5;
9337 parse_func = nsec3_parse_hash;
9338 sort_by_digest = sort_by_digest_4_5;
9339 opti_type = OPTI_TYPE_ZERO_BYTE;
9340 dgst_pos0 = 3;
9341 dgst_pos1 = 4;
9342 dgst_pos2 = 2;
9343 dgst_pos3 = 1;
9344 break;
9345
9346 case 8400: hash_type = HASH_TYPE_SHA1;
9347 salt_type = SALT_TYPE_INTERN;
9348 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9349 opts_type = OPTS_TYPE_PT_GENERATE_BE
9350 | OPTS_TYPE_PT_ADD80
9351 | OPTS_TYPE_PT_ADDBITS15;
9352 kern_type = KERN_TYPE_WBB3;
9353 dgst_size = DGST_SIZE_4_5;
9354 parse_func = wbb3_parse_hash;
9355 sort_by_digest = sort_by_digest_4_5;
9356 opti_type = OPTI_TYPE_ZERO_BYTE
9357 | OPTI_TYPE_PRECOMPUTE_INIT
9358 | OPTI_TYPE_NOT_ITERATED;
9359 dgst_pos0 = 3;
9360 dgst_pos1 = 4;
9361 dgst_pos2 = 2;
9362 dgst_pos3 = 1;
9363 break;
9364
9365 case 8500: hash_type = HASH_TYPE_DESRACF;
9366 salt_type = SALT_TYPE_EMBEDDED;
9367 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9368 opts_type = OPTS_TYPE_PT_GENERATE_LE
9369 | OPTS_TYPE_ST_UPPER;
9370 kern_type = KERN_TYPE_RACF;
9371 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9372 parse_func = racf_parse_hash;
9373 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9374 opti_type = OPTI_TYPE_ZERO_BYTE
9375 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9376 dgst_pos0 = 0;
9377 dgst_pos1 = 1;
9378 dgst_pos2 = 2;
9379 dgst_pos3 = 3;
9380 break;
9381
9382 case 8600: hash_type = HASH_TYPE_LOTUS5;
9383 salt_type = SALT_TYPE_NONE;
9384 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9385 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9386 kern_type = KERN_TYPE_LOTUS5;
9387 dgst_size = DGST_SIZE_4_4;
9388 parse_func = lotus5_parse_hash;
9389 sort_by_digest = sort_by_digest_4_4;
9390 opti_type = OPTI_TYPE_EARLY_SKIP
9391 | OPTI_TYPE_NOT_ITERATED
9392 | OPTI_TYPE_NOT_SALTED
9393 | OPTI_TYPE_RAW_HASH;
9394 dgst_pos0 = 0;
9395 dgst_pos1 = 1;
9396 dgst_pos2 = 2;
9397 dgst_pos3 = 3;
9398 break;
9399
9400 case 8700: hash_type = HASH_TYPE_LOTUS6;
9401 salt_type = SALT_TYPE_EMBEDDED;
9402 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9403 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9404 kern_type = KERN_TYPE_LOTUS6;
9405 dgst_size = DGST_SIZE_4_4;
9406 parse_func = lotus6_parse_hash;
9407 sort_by_digest = sort_by_digest_4_4;
9408 opti_type = OPTI_TYPE_EARLY_SKIP
9409 | OPTI_TYPE_NOT_ITERATED
9410 | OPTI_TYPE_RAW_HASH;
9411 dgst_pos0 = 0;
9412 dgst_pos1 = 1;
9413 dgst_pos2 = 2;
9414 dgst_pos3 = 3;
9415 break;
9416
9417 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9418 salt_type = SALT_TYPE_EMBEDDED;
9419 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9420 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9421 kern_type = KERN_TYPE_ANDROIDFDE;
9422 dgst_size = DGST_SIZE_4_4;
9423 parse_func = androidfde_parse_hash;
9424 sort_by_digest = sort_by_digest_4_4;
9425 opti_type = OPTI_TYPE_ZERO_BYTE;
9426 dgst_pos0 = 0;
9427 dgst_pos1 = 1;
9428 dgst_pos2 = 2;
9429 dgst_pos3 = 3;
9430 break;
9431
9432 case 8900: hash_type = HASH_TYPE_SCRYPT;
9433 salt_type = SALT_TYPE_EMBEDDED;
9434 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9435 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9436 kern_type = KERN_TYPE_SCRYPT;
9437 dgst_size = DGST_SIZE_4_8;
9438 parse_func = scrypt_parse_hash;
9439 sort_by_digest = sort_by_digest_4_8;
9440 opti_type = OPTI_TYPE_ZERO_BYTE;
9441 dgst_pos0 = 0;
9442 dgst_pos1 = 1;
9443 dgst_pos2 = 2;
9444 dgst_pos3 = 3;
9445 break;
9446
9447 case 9000: hash_type = HASH_TYPE_SHA1;
9448 salt_type = SALT_TYPE_EMBEDDED;
9449 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9450 opts_type = OPTS_TYPE_PT_GENERATE_LE
9451 | OPTS_TYPE_ST_GENERATE_LE;
9452 kern_type = KERN_TYPE_PSAFE2;
9453 dgst_size = DGST_SIZE_4_5;
9454 parse_func = psafe2_parse_hash;
9455 sort_by_digest = sort_by_digest_4_5;
9456 opti_type = OPTI_TYPE_ZERO_BYTE;
9457 dgst_pos0 = 0;
9458 dgst_pos1 = 1;
9459 dgst_pos2 = 2;
9460 dgst_pos3 = 3;
9461 break;
9462
9463 case 9100: hash_type = HASH_TYPE_LOTUS8;
9464 salt_type = SALT_TYPE_EMBEDDED;
9465 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9466 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9467 kern_type = KERN_TYPE_LOTUS8;
9468 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9469 parse_func = lotus8_parse_hash;
9470 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9471 opti_type = OPTI_TYPE_ZERO_BYTE;
9472 dgst_pos0 = 0;
9473 dgst_pos1 = 1;
9474 dgst_pos2 = 2;
9475 dgst_pos3 = 3;
9476 break;
9477
9478 case 9200: hash_type = HASH_TYPE_SHA256;
9479 salt_type = SALT_TYPE_EMBEDDED;
9480 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9481 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9482 kern_type = KERN_TYPE_PBKDF2_SHA256;
9483 dgst_size = DGST_SIZE_4_32;
9484 parse_func = cisco8_parse_hash;
9485 sort_by_digest = sort_by_digest_4_32;
9486 opti_type = OPTI_TYPE_ZERO_BYTE;
9487 dgst_pos0 = 0;
9488 dgst_pos1 = 1;
9489 dgst_pos2 = 2;
9490 dgst_pos3 = 3;
9491 break;
9492
9493 case 9300: hash_type = HASH_TYPE_SCRYPT;
9494 salt_type = SALT_TYPE_EMBEDDED;
9495 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9496 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9497 kern_type = KERN_TYPE_SCRYPT;
9498 dgst_size = DGST_SIZE_4_8;
9499 parse_func = cisco9_parse_hash;
9500 sort_by_digest = sort_by_digest_4_8;
9501 opti_type = OPTI_TYPE_ZERO_BYTE;
9502 dgst_pos0 = 0;
9503 dgst_pos1 = 1;
9504 dgst_pos2 = 2;
9505 dgst_pos3 = 3;
9506 break;
9507
9508 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9509 salt_type = SALT_TYPE_EMBEDDED;
9510 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9511 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9512 kern_type = KERN_TYPE_OFFICE2007;
9513 dgst_size = DGST_SIZE_4_4;
9514 parse_func = office2007_parse_hash;
9515 sort_by_digest = sort_by_digest_4_4;
9516 opti_type = OPTI_TYPE_ZERO_BYTE;
9517 dgst_pos0 = 0;
9518 dgst_pos1 = 1;
9519 dgst_pos2 = 2;
9520 dgst_pos3 = 3;
9521 break;
9522
9523 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9524 salt_type = SALT_TYPE_EMBEDDED;
9525 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9526 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9527 kern_type = KERN_TYPE_OFFICE2010;
9528 dgst_size = DGST_SIZE_4_4;
9529 parse_func = office2010_parse_hash;
9530 sort_by_digest = sort_by_digest_4_4;
9531 opti_type = OPTI_TYPE_ZERO_BYTE;
9532 dgst_pos0 = 0;
9533 dgst_pos1 = 1;
9534 dgst_pos2 = 2;
9535 dgst_pos3 = 3;
9536 break;
9537
9538 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9539 salt_type = SALT_TYPE_EMBEDDED;
9540 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9541 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9542 kern_type = KERN_TYPE_OFFICE2013;
9543 dgst_size = DGST_SIZE_4_4;
9544 parse_func = office2013_parse_hash;
9545 sort_by_digest = sort_by_digest_4_4;
9546 opti_type = OPTI_TYPE_ZERO_BYTE;
9547 dgst_pos0 = 0;
9548 dgst_pos1 = 1;
9549 dgst_pos2 = 2;
9550 dgst_pos3 = 3;
9551 break;
9552
9553 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9554 salt_type = SALT_TYPE_EMBEDDED;
9555 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9556 opts_type = OPTS_TYPE_PT_GENERATE_LE
9557 | OPTS_TYPE_PT_ADD80
9558 | OPTS_TYPE_PT_UNICODE;
9559 kern_type = KERN_TYPE_OLDOFFICE01;
9560 dgst_size = DGST_SIZE_4_4;
9561 parse_func = oldoffice01_parse_hash;
9562 sort_by_digest = sort_by_digest_4_4;
9563 opti_type = OPTI_TYPE_ZERO_BYTE
9564 | OPTI_TYPE_PRECOMPUTE_INIT
9565 | OPTI_TYPE_NOT_ITERATED;
9566 dgst_pos0 = 0;
9567 dgst_pos1 = 1;
9568 dgst_pos2 = 2;
9569 dgst_pos3 = 3;
9570 break;
9571
9572 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9573 salt_type = SALT_TYPE_EMBEDDED;
9574 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9575 opts_type = OPTS_TYPE_PT_GENERATE_LE
9576 | OPTS_TYPE_PT_ADD80;
9577 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9578 dgst_size = DGST_SIZE_4_4;
9579 parse_func = oldoffice01cm1_parse_hash;
9580 sort_by_digest = sort_by_digest_4_4;
9581 opti_type = OPTI_TYPE_ZERO_BYTE
9582 | OPTI_TYPE_PRECOMPUTE_INIT
9583 | OPTI_TYPE_NOT_ITERATED;
9584 dgst_pos0 = 0;
9585 dgst_pos1 = 1;
9586 dgst_pos2 = 2;
9587 dgst_pos3 = 3;
9588 break;
9589
9590 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9591 salt_type = SALT_TYPE_EMBEDDED;
9592 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9593 opts_type = OPTS_TYPE_PT_GENERATE_LE
9594 | OPTS_TYPE_PT_ADD80
9595 | OPTS_TYPE_PT_UNICODE
9596 | OPTS_TYPE_PT_NEVERCRACK;
9597 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9598 dgst_size = DGST_SIZE_4_4;
9599 parse_func = oldoffice01cm2_parse_hash;
9600 sort_by_digest = sort_by_digest_4_4;
9601 opti_type = OPTI_TYPE_ZERO_BYTE
9602 | OPTI_TYPE_PRECOMPUTE_INIT
9603 | OPTI_TYPE_NOT_ITERATED;
9604 dgst_pos0 = 0;
9605 dgst_pos1 = 1;
9606 dgst_pos2 = 2;
9607 dgst_pos3 = 3;
9608 break;
9609
9610 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9611 salt_type = SALT_TYPE_EMBEDDED;
9612 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9613 opts_type = OPTS_TYPE_PT_GENERATE_BE
9614 | OPTS_TYPE_PT_ADD80
9615 | OPTS_TYPE_PT_UNICODE;
9616 kern_type = KERN_TYPE_OLDOFFICE34;
9617 dgst_size = DGST_SIZE_4_4;
9618 parse_func = oldoffice34_parse_hash;
9619 sort_by_digest = sort_by_digest_4_4;
9620 opti_type = OPTI_TYPE_ZERO_BYTE
9621 | OPTI_TYPE_PRECOMPUTE_INIT
9622 | OPTI_TYPE_NOT_ITERATED;
9623 dgst_pos0 = 0;
9624 dgst_pos1 = 1;
9625 dgst_pos2 = 2;
9626 dgst_pos3 = 3;
9627 break;
9628
9629 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9630 salt_type = SALT_TYPE_EMBEDDED;
9631 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9632 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9633 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9634 dgst_size = DGST_SIZE_4_4;
9635 parse_func = oldoffice34cm1_parse_hash;
9636 sort_by_digest = sort_by_digest_4_4;
9637 opti_type = OPTI_TYPE_ZERO_BYTE
9638 | OPTI_TYPE_PRECOMPUTE_INIT
9639 | OPTI_TYPE_NOT_ITERATED;
9640 dgst_pos0 = 0;
9641 dgst_pos1 = 1;
9642 dgst_pos2 = 2;
9643 dgst_pos3 = 3;
9644 break;
9645
9646 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9647 salt_type = SALT_TYPE_EMBEDDED;
9648 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9649 opts_type = OPTS_TYPE_PT_GENERATE_BE
9650 | OPTS_TYPE_PT_ADD80
9651 | OPTS_TYPE_PT_UNICODE
9652 | OPTS_TYPE_PT_NEVERCRACK;
9653 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9654 dgst_size = DGST_SIZE_4_4;
9655 parse_func = oldoffice34cm2_parse_hash;
9656 sort_by_digest = sort_by_digest_4_4;
9657 opti_type = OPTI_TYPE_ZERO_BYTE
9658 | OPTI_TYPE_PRECOMPUTE_INIT
9659 | OPTI_TYPE_NOT_ITERATED;
9660 dgst_pos0 = 0;
9661 dgst_pos1 = 1;
9662 dgst_pos2 = 2;
9663 dgst_pos3 = 3;
9664 break;
9665
9666 case 9900: hash_type = HASH_TYPE_MD5;
9667 salt_type = SALT_TYPE_NONE;
9668 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9669 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9670 kern_type = KERN_TYPE_RADMIN2;
9671 dgst_size = DGST_SIZE_4_4;
9672 parse_func = radmin2_parse_hash;
9673 sort_by_digest = sort_by_digest_4_4;
9674 opti_type = OPTI_TYPE_ZERO_BYTE
9675 | OPTI_TYPE_PRECOMPUTE_INIT
9676 | OPTI_TYPE_EARLY_SKIP
9677 | OPTI_TYPE_NOT_ITERATED
9678 | OPTI_TYPE_NOT_SALTED;
9679 dgst_pos0 = 0;
9680 dgst_pos1 = 3;
9681 dgst_pos2 = 2;
9682 dgst_pos3 = 1;
9683 break;
9684
9685 case 10000: hash_type = HASH_TYPE_SHA256;
9686 salt_type = SALT_TYPE_EMBEDDED;
9687 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9688 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9689 kern_type = KERN_TYPE_PBKDF2_SHA256;
9690 dgst_size = DGST_SIZE_4_32;
9691 parse_func = djangopbkdf2_parse_hash;
9692 sort_by_digest = sort_by_digest_4_32;
9693 opti_type = OPTI_TYPE_ZERO_BYTE;
9694 dgst_pos0 = 0;
9695 dgst_pos1 = 1;
9696 dgst_pos2 = 2;
9697 dgst_pos3 = 3;
9698 break;
9699
9700 case 10100: hash_type = HASH_TYPE_SIPHASH;
9701 salt_type = SALT_TYPE_EMBEDDED;
9702 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9703 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9704 kern_type = KERN_TYPE_SIPHASH;
9705 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9706 parse_func = siphash_parse_hash;
9707 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9708 opti_type = OPTI_TYPE_ZERO_BYTE
9709 | OPTI_TYPE_NOT_ITERATED
9710 | OPTI_TYPE_RAW_HASH;
9711 dgst_pos0 = 0;
9712 dgst_pos1 = 1;
9713 dgst_pos2 = 2;
9714 dgst_pos3 = 3;
9715 break;
9716
9717 case 10200: hash_type = HASH_TYPE_MD5;
9718 salt_type = SALT_TYPE_EMBEDDED;
9719 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9720 opts_type = OPTS_TYPE_PT_GENERATE_LE
9721 | OPTS_TYPE_ST_ADD80
9722 | OPTS_TYPE_ST_ADDBITS14;
9723 kern_type = KERN_TYPE_HMACMD5_PW;
9724 dgst_size = DGST_SIZE_4_4;
9725 parse_func = crammd5_parse_hash;
9726 sort_by_digest = sort_by_digest_4_4;
9727 opti_type = OPTI_TYPE_ZERO_BYTE
9728 | OPTI_TYPE_NOT_ITERATED;
9729 dgst_pos0 = 0;
9730 dgst_pos1 = 3;
9731 dgst_pos2 = 2;
9732 dgst_pos3 = 1;
9733 break;
9734
9735 case 10300: hash_type = HASH_TYPE_SHA1;
9736 salt_type = SALT_TYPE_EMBEDDED;
9737 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9738 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9739 kern_type = KERN_TYPE_SAPH_SHA1;
9740 dgst_size = DGST_SIZE_4_5;
9741 parse_func = saph_sha1_parse_hash;
9742 sort_by_digest = sort_by_digest_4_5;
9743 opti_type = OPTI_TYPE_ZERO_BYTE;
9744 dgst_pos0 = 0;
9745 dgst_pos1 = 1;
9746 dgst_pos2 = 2;
9747 dgst_pos3 = 3;
9748 break;
9749
9750 case 10400: hash_type = HASH_TYPE_PDFU16;
9751 salt_type = SALT_TYPE_EMBEDDED;
9752 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9753 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9754 kern_type = KERN_TYPE_PDF11;
9755 dgst_size = DGST_SIZE_4_4;
9756 parse_func = pdf11_parse_hash;
9757 sort_by_digest = sort_by_digest_4_4;
9758 opti_type = OPTI_TYPE_ZERO_BYTE
9759 | OPTI_TYPE_NOT_ITERATED;
9760 dgst_pos0 = 0;
9761 dgst_pos1 = 1;
9762 dgst_pos2 = 2;
9763 dgst_pos3 = 3;
9764 break;
9765
9766 case 10410: hash_type = HASH_TYPE_PDFU16;
9767 salt_type = SALT_TYPE_EMBEDDED;
9768 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9769 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9770 kern_type = KERN_TYPE_PDF11CM1;
9771 dgst_size = DGST_SIZE_4_4;
9772 parse_func = pdf11cm1_parse_hash;
9773 sort_by_digest = sort_by_digest_4_4;
9774 opti_type = OPTI_TYPE_ZERO_BYTE
9775 | OPTI_TYPE_NOT_ITERATED;
9776 dgst_pos0 = 0;
9777 dgst_pos1 = 1;
9778 dgst_pos2 = 2;
9779 dgst_pos3 = 3;
9780 break;
9781
9782 case 10420: hash_type = HASH_TYPE_PDFU16;
9783 salt_type = SALT_TYPE_EMBEDDED;
9784 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9785 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9786 kern_type = KERN_TYPE_PDF11CM2;
9787 dgst_size = DGST_SIZE_4_4;
9788 parse_func = pdf11cm2_parse_hash;
9789 sort_by_digest = sort_by_digest_4_4;
9790 opti_type = OPTI_TYPE_ZERO_BYTE
9791 | OPTI_TYPE_NOT_ITERATED;
9792 dgst_pos0 = 0;
9793 dgst_pos1 = 1;
9794 dgst_pos2 = 2;
9795 dgst_pos3 = 3;
9796 break;
9797
9798 case 10500: hash_type = HASH_TYPE_PDFU16;
9799 salt_type = SALT_TYPE_EMBEDDED;
9800 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9801 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9802 kern_type = KERN_TYPE_PDF14;
9803 dgst_size = DGST_SIZE_4_4;
9804 parse_func = pdf14_parse_hash;
9805 sort_by_digest = sort_by_digest_4_4;
9806 opti_type = OPTI_TYPE_ZERO_BYTE
9807 | OPTI_TYPE_NOT_ITERATED;
9808 dgst_pos0 = 0;
9809 dgst_pos1 = 1;
9810 dgst_pos2 = 2;
9811 dgst_pos3 = 3;
9812 break;
9813
9814 case 10600: hash_type = HASH_TYPE_SHA256;
9815 salt_type = SALT_TYPE_EMBEDDED;
9816 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9817 opts_type = OPTS_TYPE_PT_GENERATE_BE
9818 | OPTS_TYPE_ST_ADD80
9819 | OPTS_TYPE_ST_ADDBITS15
9820 | OPTS_TYPE_HASH_COPY;
9821 kern_type = KERN_TYPE_SHA256_PWSLT;
9822 dgst_size = DGST_SIZE_4_8;
9823 parse_func = pdf17l3_parse_hash;
9824 sort_by_digest = sort_by_digest_4_8;
9825 opti_type = OPTI_TYPE_ZERO_BYTE
9826 | OPTI_TYPE_PRECOMPUTE_INIT
9827 | OPTI_TYPE_PRECOMPUTE_MERKLE
9828 | OPTI_TYPE_EARLY_SKIP
9829 | OPTI_TYPE_NOT_ITERATED
9830 | OPTI_TYPE_APPENDED_SALT
9831 | OPTI_TYPE_RAW_HASH;
9832 dgst_pos0 = 3;
9833 dgst_pos1 = 7;
9834 dgst_pos2 = 2;
9835 dgst_pos3 = 6;
9836 break;
9837
9838 case 10700: hash_type = HASH_TYPE_PDFU32;
9839 salt_type = SALT_TYPE_EMBEDDED;
9840 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9841 opts_type = OPTS_TYPE_PT_GENERATE_LE
9842 | OPTS_TYPE_HASH_COPY;
9843 kern_type = KERN_TYPE_PDF17L8;
9844 dgst_size = DGST_SIZE_4_8;
9845 parse_func = pdf17l8_parse_hash;
9846 sort_by_digest = sort_by_digest_4_8;
9847 opti_type = OPTI_TYPE_ZERO_BYTE
9848 | OPTI_TYPE_NOT_ITERATED;
9849 dgst_pos0 = 0;
9850 dgst_pos1 = 1;
9851 dgst_pos2 = 2;
9852 dgst_pos3 = 3;
9853 break;
9854
9855 case 10800: hash_type = HASH_TYPE_SHA384;
9856 salt_type = SALT_TYPE_NONE;
9857 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9858 opts_type = OPTS_TYPE_PT_GENERATE_BE
9859 | OPTS_TYPE_PT_ADD80
9860 | OPTS_TYPE_PT_ADDBITS15;
9861 kern_type = KERN_TYPE_SHA384;
9862 dgst_size = DGST_SIZE_8_8;
9863 parse_func = sha384_parse_hash;
9864 sort_by_digest = sort_by_digest_8_8;
9865 opti_type = OPTI_TYPE_ZERO_BYTE
9866 | OPTI_TYPE_PRECOMPUTE_INIT
9867 | OPTI_TYPE_PRECOMPUTE_MERKLE
9868 | OPTI_TYPE_EARLY_SKIP
9869 | OPTI_TYPE_NOT_ITERATED
9870 | OPTI_TYPE_NOT_SALTED
9871 | OPTI_TYPE_USES_BITS_64
9872 | OPTI_TYPE_RAW_HASH;
9873 dgst_pos0 = 6;
9874 dgst_pos1 = 7;
9875 dgst_pos2 = 4;
9876 dgst_pos3 = 5;
9877 break;
9878
9879 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9880 salt_type = SALT_TYPE_EMBEDDED;
9881 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9882 opts_type = OPTS_TYPE_PT_GENERATE_LE
9883 | OPTS_TYPE_ST_BASE64
9884 | OPTS_TYPE_HASH_COPY;
9885 kern_type = KERN_TYPE_PBKDF2_SHA256;
9886 dgst_size = DGST_SIZE_4_32;
9887 parse_func = pbkdf2_sha256_parse_hash;
9888 sort_by_digest = sort_by_digest_4_32;
9889 opti_type = OPTI_TYPE_ZERO_BYTE;
9890 dgst_pos0 = 0;
9891 dgst_pos1 = 1;
9892 dgst_pos2 = 2;
9893 dgst_pos3 = 3;
9894 break;
9895
9896 case 11000: hash_type = HASH_TYPE_MD5;
9897 salt_type = SALT_TYPE_INTERN;
9898 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9899 opts_type = OPTS_TYPE_PT_GENERATE_LE
9900 | OPTS_TYPE_PT_ADD80;
9901 kern_type = KERN_TYPE_PRESTASHOP;
9902 dgst_size = DGST_SIZE_4_4;
9903 parse_func = prestashop_parse_hash;
9904 sort_by_digest = sort_by_digest_4_4;
9905 opti_type = OPTI_TYPE_ZERO_BYTE
9906 | OPTI_TYPE_PRECOMPUTE_INIT
9907 | OPTI_TYPE_NOT_ITERATED
9908 | OPTI_TYPE_PREPENDED_SALT;
9909 dgst_pos0 = 0;
9910 dgst_pos1 = 3;
9911 dgst_pos2 = 2;
9912 dgst_pos3 = 1;
9913 break;
9914
9915 case 11100: hash_type = HASH_TYPE_MD5;
9916 salt_type = SALT_TYPE_EMBEDDED;
9917 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9918 opts_type = OPTS_TYPE_PT_GENERATE_LE
9919 | OPTS_TYPE_ST_ADD80;
9920 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9921 dgst_size = DGST_SIZE_4_4;
9922 parse_func = postgresql_auth_parse_hash;
9923 sort_by_digest = sort_by_digest_4_4;
9924 opti_type = OPTI_TYPE_ZERO_BYTE
9925 | OPTI_TYPE_PRECOMPUTE_INIT
9926 | OPTI_TYPE_PRECOMPUTE_MERKLE
9927 | OPTI_TYPE_EARLY_SKIP;
9928 dgst_pos0 = 0;
9929 dgst_pos1 = 3;
9930 dgst_pos2 = 2;
9931 dgst_pos3 = 1;
9932 break;
9933
9934 case 11200: hash_type = HASH_TYPE_SHA1;
9935 salt_type = SALT_TYPE_EMBEDDED;
9936 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9937 opts_type = OPTS_TYPE_PT_GENERATE_BE
9938 | OPTS_TYPE_PT_ADD80
9939 | OPTS_TYPE_ST_HEX;
9940 kern_type = KERN_TYPE_MYSQL_AUTH;
9941 dgst_size = DGST_SIZE_4_5;
9942 parse_func = mysql_auth_parse_hash;
9943 sort_by_digest = sort_by_digest_4_5;
9944 opti_type = OPTI_TYPE_ZERO_BYTE
9945 | OPTI_TYPE_EARLY_SKIP;
9946 dgst_pos0 = 3;
9947 dgst_pos1 = 4;
9948 dgst_pos2 = 2;
9949 dgst_pos3 = 1;
9950 break;
9951
9952 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9953 salt_type = SALT_TYPE_EMBEDDED;
9954 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9955 opts_type = OPTS_TYPE_PT_GENERATE_LE
9956 | OPTS_TYPE_ST_HEX
9957 | OPTS_TYPE_ST_ADD80;
9958 kern_type = KERN_TYPE_BITCOIN_WALLET;
9959 dgst_size = DGST_SIZE_4_4;
9960 parse_func = bitcoin_wallet_parse_hash;
9961 sort_by_digest = sort_by_digest_4_4;
9962 opti_type = OPTI_TYPE_ZERO_BYTE;
9963 dgst_pos0 = 0;
9964 dgst_pos1 = 1;
9965 dgst_pos2 = 2;
9966 dgst_pos3 = 3;
9967 break;
9968
9969 case 11400: hash_type = HASH_TYPE_MD5;
9970 salt_type = SALT_TYPE_EMBEDDED;
9971 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9972 opts_type = OPTS_TYPE_PT_GENERATE_LE
9973 | OPTS_TYPE_PT_ADD80
9974 | OPTS_TYPE_HASH_COPY;
9975 kern_type = KERN_TYPE_SIP_AUTH;
9976 dgst_size = DGST_SIZE_4_4;
9977 parse_func = sip_auth_parse_hash;
9978 sort_by_digest = sort_by_digest_4_4;
9979 opti_type = OPTI_TYPE_ZERO_BYTE;
9980 dgst_pos0 = 0;
9981 dgst_pos1 = 3;
9982 dgst_pos2 = 2;
9983 dgst_pos3 = 1;
9984 break;
9985
9986 case 11500: hash_type = HASH_TYPE_CRC32;
9987 salt_type = SALT_TYPE_INTERN;
9988 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9989 opts_type = OPTS_TYPE_PT_GENERATE_LE
9990 | OPTS_TYPE_ST_GENERATE_LE
9991 | OPTS_TYPE_ST_HEX;
9992 kern_type = KERN_TYPE_CRC32;
9993 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9994 parse_func = crc32_parse_hash;
9995 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9996 opti_type = OPTI_TYPE_ZERO_BYTE;
9997 dgst_pos0 = 0;
9998 dgst_pos1 = 1;
9999 dgst_pos2 = 2;
10000 dgst_pos3 = 3;
10001 break;
10002
10003 case 11600: hash_type = HASH_TYPE_AES;
10004 salt_type = SALT_TYPE_EMBEDDED;
10005 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10006 opts_type = OPTS_TYPE_PT_GENERATE_LE
10007 | OPTS_TYPE_PT_NEVERCRACK;
10008 kern_type = KERN_TYPE_SEVEN_ZIP;
10009 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10010 parse_func = seven_zip_parse_hash;
10011 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10012 opti_type = OPTI_TYPE_ZERO_BYTE;
10013 dgst_pos0 = 0;
10014 dgst_pos1 = 1;
10015 dgst_pos2 = 2;
10016 dgst_pos3 = 3;
10017 break;
10018
10019 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10020 salt_type = SALT_TYPE_NONE;
10021 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10022 opts_type = OPTS_TYPE_PT_GENERATE_LE
10023 | OPTS_TYPE_PT_ADD01;
10024 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10025 dgst_size = DGST_SIZE_4_8;
10026 parse_func = gost2012sbog_256_parse_hash;
10027 sort_by_digest = sort_by_digest_4_8;
10028 opti_type = OPTI_TYPE_ZERO_BYTE;
10029 dgst_pos0 = 0;
10030 dgst_pos1 = 1;
10031 dgst_pos2 = 2;
10032 dgst_pos3 = 3;
10033 break;
10034
10035 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10036 salt_type = SALT_TYPE_NONE;
10037 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10038 opts_type = OPTS_TYPE_PT_GENERATE_LE
10039 | OPTS_TYPE_PT_ADD01;
10040 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10041 dgst_size = DGST_SIZE_4_16;
10042 parse_func = gost2012sbog_512_parse_hash;
10043 sort_by_digest = sort_by_digest_4_16;
10044 opti_type = OPTI_TYPE_ZERO_BYTE;
10045 dgst_pos0 = 0;
10046 dgst_pos1 = 1;
10047 dgst_pos2 = 2;
10048 dgst_pos3 = 3;
10049 break;
10050
10051 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10052 salt_type = SALT_TYPE_EMBEDDED;
10053 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10054 opts_type = OPTS_TYPE_PT_GENERATE_LE
10055 | OPTS_TYPE_ST_BASE64
10056 | OPTS_TYPE_HASH_COPY;
10057 kern_type = KERN_TYPE_PBKDF2_MD5;
10058 dgst_size = DGST_SIZE_4_32;
10059 parse_func = pbkdf2_md5_parse_hash;
10060 sort_by_digest = sort_by_digest_4_32;
10061 opti_type = OPTI_TYPE_ZERO_BYTE;
10062 dgst_pos0 = 0;
10063 dgst_pos1 = 1;
10064 dgst_pos2 = 2;
10065 dgst_pos3 = 3;
10066 break;
10067
10068 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10069 salt_type = SALT_TYPE_EMBEDDED;
10070 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10071 opts_type = OPTS_TYPE_PT_GENERATE_LE
10072 | OPTS_TYPE_ST_BASE64
10073 | OPTS_TYPE_HASH_COPY;
10074 kern_type = KERN_TYPE_PBKDF2_SHA1;
10075 dgst_size = DGST_SIZE_4_32;
10076 parse_func = pbkdf2_sha1_parse_hash;
10077 sort_by_digest = sort_by_digest_4_32;
10078 opti_type = OPTI_TYPE_ZERO_BYTE;
10079 dgst_pos0 = 0;
10080 dgst_pos1 = 1;
10081 dgst_pos2 = 2;
10082 dgst_pos3 = 3;
10083 break;
10084
10085 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10086 salt_type = SALT_TYPE_EMBEDDED;
10087 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10088 opts_type = OPTS_TYPE_PT_GENERATE_LE
10089 | OPTS_TYPE_ST_BASE64
10090 | OPTS_TYPE_HASH_COPY;
10091 kern_type = KERN_TYPE_PBKDF2_SHA512;
10092 dgst_size = DGST_SIZE_8_16;
10093 parse_func = pbkdf2_sha512_parse_hash;
10094 sort_by_digest = sort_by_digest_8_16;
10095 opti_type = OPTI_TYPE_ZERO_BYTE
10096 | OPTI_TYPE_USES_BITS_64;
10097 dgst_pos0 = 0;
10098 dgst_pos1 = 1;
10099 dgst_pos2 = 2;
10100 dgst_pos3 = 3;
10101 break;
10102
10103 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10104 salt_type = SALT_TYPE_EMBEDDED;
10105 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10106 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10107 kern_type = KERN_TYPE_ECRYPTFS;
10108 dgst_size = DGST_SIZE_8_8;
10109 parse_func = ecryptfs_parse_hash;
10110 sort_by_digest = sort_by_digest_8_8;
10111 opti_type = OPTI_TYPE_ZERO_BYTE
10112 | OPTI_TYPE_USES_BITS_64;
10113 dgst_pos0 = 0;
10114 dgst_pos1 = 1;
10115 dgst_pos2 = 2;
10116 dgst_pos3 = 3;
10117 break;
10118
10119 case 12300: hash_type = HASH_TYPE_ORACLET;
10120 salt_type = SALT_TYPE_EMBEDDED;
10121 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10122 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10123 kern_type = KERN_TYPE_ORACLET;
10124 dgst_size = DGST_SIZE_8_16;
10125 parse_func = oraclet_parse_hash;
10126 sort_by_digest = sort_by_digest_8_16;
10127 opti_type = OPTI_TYPE_ZERO_BYTE
10128 | OPTI_TYPE_USES_BITS_64;
10129 dgst_pos0 = 0;
10130 dgst_pos1 = 1;
10131 dgst_pos2 = 2;
10132 dgst_pos3 = 3;
10133 break;
10134
10135 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10136 salt_type = SALT_TYPE_EMBEDDED;
10137 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10138 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10139 kern_type = KERN_TYPE_BSDICRYPT;
10140 dgst_size = DGST_SIZE_4_4;
10141 parse_func = bsdicrypt_parse_hash;
10142 sort_by_digest = sort_by_digest_4_4;
10143 opti_type = OPTI_TYPE_ZERO_BYTE
10144 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10145 dgst_pos0 = 0;
10146 dgst_pos1 = 1;
10147 dgst_pos2 = 2;
10148 dgst_pos3 = 3;
10149 break;
10150
10151 case 12500: hash_type = HASH_TYPE_RAR3HP;
10152 salt_type = SALT_TYPE_EMBEDDED;
10153 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10154 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10155 kern_type = KERN_TYPE_RAR3;
10156 dgst_size = DGST_SIZE_4_4;
10157 parse_func = rar3hp_parse_hash;
10158 sort_by_digest = sort_by_digest_4_4;
10159 opti_type = OPTI_TYPE_ZERO_BYTE;
10160 dgst_pos0 = 0;
10161 dgst_pos1 = 1;
10162 dgst_pos2 = 2;
10163 dgst_pos3 = 3;
10164 break;
10165
10166 case 12600: hash_type = HASH_TYPE_SHA256;
10167 salt_type = SALT_TYPE_INTERN;
10168 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10169 opts_type = OPTS_TYPE_PT_GENERATE_BE
10170 | OPTS_TYPE_PT_ADD80;
10171 kern_type = KERN_TYPE_CF10;
10172 dgst_size = DGST_SIZE_4_8;
10173 parse_func = cf10_parse_hash;
10174 sort_by_digest = sort_by_digest_4_8;
10175 opti_type = OPTI_TYPE_ZERO_BYTE
10176 | OPTI_TYPE_PRECOMPUTE_INIT
10177 | OPTI_TYPE_EARLY_SKIP
10178 | OPTI_TYPE_NOT_ITERATED;
10179 dgst_pos0 = 3;
10180 dgst_pos1 = 7;
10181 dgst_pos2 = 2;
10182 dgst_pos3 = 6;
10183 break;
10184
10185 case 12700: hash_type = HASH_TYPE_AES;
10186 salt_type = SALT_TYPE_EMBEDDED;
10187 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10188 opts_type = OPTS_TYPE_PT_GENERATE_LE
10189 | OPTS_TYPE_HASH_COPY;
10190 kern_type = KERN_TYPE_MYWALLET;
10191 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10192 parse_func = mywallet_parse_hash;
10193 sort_by_digest = sort_by_digest_4_5;
10194 opti_type = OPTI_TYPE_ZERO_BYTE;
10195 dgst_pos0 = 0;
10196 dgst_pos1 = 1;
10197 dgst_pos2 = 2;
10198 dgst_pos3 = 3;
10199 break;
10200
10201 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10202 salt_type = SALT_TYPE_EMBEDDED;
10203 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10204 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10205 kern_type = KERN_TYPE_MS_DRSR;
10206 dgst_size = DGST_SIZE_4_8;
10207 parse_func = ms_drsr_parse_hash;
10208 sort_by_digest = sort_by_digest_4_8;
10209 opti_type = OPTI_TYPE_ZERO_BYTE;
10210 dgst_pos0 = 0;
10211 dgst_pos1 = 1;
10212 dgst_pos2 = 2;
10213 dgst_pos3 = 3;
10214 break;
10215
10216 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10217 salt_type = SALT_TYPE_EMBEDDED;
10218 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10219 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10220 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10221 dgst_size = DGST_SIZE_4_8;
10222 parse_func = androidfde_samsung_parse_hash;
10223 sort_by_digest = sort_by_digest_4_8;
10224 opti_type = OPTI_TYPE_ZERO_BYTE;
10225 dgst_pos0 = 0;
10226 dgst_pos1 = 1;
10227 dgst_pos2 = 2;
10228 dgst_pos3 = 3;
10229 break;
10230
10231 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10232 salt_type = SALT_TYPE_EMBEDDED;
10233 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10234 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10235 kern_type = KERN_TYPE_RAR5;
10236 dgst_size = DGST_SIZE_4_4;
10237 parse_func = rar5_parse_hash;
10238 sort_by_digest = sort_by_digest_4_4;
10239 opti_type = OPTI_TYPE_ZERO_BYTE;
10240 dgst_pos0 = 0;
10241 dgst_pos1 = 1;
10242 dgst_pos2 = 2;
10243 dgst_pos3 = 3;
10244 break;
10245
10246 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10247 salt_type = SALT_TYPE_EMBEDDED;
10248 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10249 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10250 kern_type = KERN_TYPE_KRB5TGS;
10251 dgst_size = DGST_SIZE_4_4;
10252 parse_func = krb5tgs_parse_hash;
10253 sort_by_digest = sort_by_digest_4_4;
10254 opti_type = OPTI_TYPE_ZERO_BYTE
10255 | OPTI_TYPE_NOT_ITERATED;
10256 dgst_pos0 = 0;
10257 dgst_pos1 = 1;
10258 dgst_pos2 = 2;
10259 dgst_pos3 = 3;
10260 break;
10261
10262 case 13200: hash_type = HASH_TYPE_AES;
10263 salt_type = SALT_TYPE_EMBEDDED;
10264 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10265 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10266 kern_type = KERN_TYPE_AXCRYPT;
10267 dgst_size = DGST_SIZE_4_4;
10268 parse_func = axcrypt_parse_hash;
10269 sort_by_digest = sort_by_digest_4_4;
10270 opti_type = OPTI_TYPE_ZERO_BYTE;
10271 dgst_pos0 = 0;
10272 dgst_pos1 = 1;
10273 dgst_pos2 = 2;
10274 dgst_pos3 = 3;
10275 break;
10276
10277 case 13300: hash_type = HASH_TYPE_SHA1;
10278 salt_type = SALT_TYPE_NONE;
10279 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10280 opts_type = OPTS_TYPE_PT_GENERATE_BE
10281 | OPTS_TYPE_PT_ADD80
10282 | OPTS_TYPE_PT_ADDBITS15;
10283 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10284 dgst_size = DGST_SIZE_4_5;
10285 parse_func = sha1axcrypt_parse_hash;
10286 sort_by_digest = sort_by_digest_4_5;
10287 opti_type = OPTI_TYPE_ZERO_BYTE
10288 | OPTI_TYPE_PRECOMPUTE_INIT
10289 | OPTI_TYPE_EARLY_SKIP
10290 | OPTI_TYPE_NOT_ITERATED
10291 | OPTI_TYPE_NOT_SALTED;
10292 dgst_pos0 = 0;
10293 dgst_pos1 = 4;
10294 dgst_pos2 = 3;
10295 dgst_pos3 = 2;
10296 break;
10297
10298 case 13400: hash_type = HASH_TYPE_AES;
10299 salt_type = SALT_TYPE_EMBEDDED;
10300 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10301 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10302 kern_type = KERN_TYPE_KEEPASS;
10303 dgst_size = DGST_SIZE_4_4;
10304 parse_func = keepass_parse_hash;
10305 sort_by_digest = sort_by_digest_4_4;
10306 opti_type = OPTI_TYPE_ZERO_BYTE;
10307 dgst_pos0 = 0;
10308 dgst_pos1 = 1;
10309 dgst_pos2 = 2;
10310 dgst_pos3 = 3;
10311 break;
10312
10313 default: usage_mini_print (PROGNAME); return (-1);
10314 }
10315
10316 /**
10317 * parser
10318 */
10319
10320 data.parse_func = parse_func;
10321
10322 /**
10323 * misc stuff
10324 */
10325
10326 if (hex_salt)
10327 {
10328 if (salt_type == SALT_TYPE_INTERN)
10329 {
10330 opts_type |= OPTS_TYPE_ST_HEX;
10331 }
10332 else
10333 {
10334 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10335
10336 return (-1);
10337 }
10338 }
10339
10340 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10341 | (salt_type == SALT_TYPE_EXTERN)
10342 | (salt_type == SALT_TYPE_EMBEDDED)
10343 | (salt_type == SALT_TYPE_VIRTUAL));
10344
10345 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10346
10347 data.hash_type = hash_type;
10348 data.attack_mode = attack_mode;
10349 data.attack_kern = attack_kern;
10350 data.attack_exec = attack_exec;
10351 data.kern_type = kern_type;
10352 data.opts_type = opts_type;
10353 data.dgst_size = dgst_size;
10354 data.salt_type = salt_type;
10355 data.isSalted = isSalted;
10356 data.sort_by_digest = sort_by_digest;
10357 data.dgst_pos0 = dgst_pos0;
10358 data.dgst_pos1 = dgst_pos1;
10359 data.dgst_pos2 = dgst_pos2;
10360 data.dgst_pos3 = dgst_pos3;
10361
10362 esalt_size = 0;
10363
10364 switch (hash_mode)
10365 {
10366 case 2500: esalt_size = sizeof (wpa_t); break;
10367 case 5300: esalt_size = sizeof (ikepsk_t); break;
10368 case 5400: esalt_size = sizeof (ikepsk_t); break;
10369 case 5500: esalt_size = sizeof (netntlm_t); break;
10370 case 5600: esalt_size = sizeof (netntlm_t); break;
10371 case 6211: esalt_size = sizeof (tc_t); break;
10372 case 6212: esalt_size = sizeof (tc_t); break;
10373 case 6213: esalt_size = sizeof (tc_t); break;
10374 case 6221: esalt_size = sizeof (tc_t); break;
10375 case 6222: esalt_size = sizeof (tc_t); break;
10376 case 6223: esalt_size = sizeof (tc_t); break;
10377 case 6231: esalt_size = sizeof (tc_t); break;
10378 case 6232: esalt_size = sizeof (tc_t); break;
10379 case 6233: esalt_size = sizeof (tc_t); break;
10380 case 6241: esalt_size = sizeof (tc_t); break;
10381 case 6242: esalt_size = sizeof (tc_t); break;
10382 case 6243: esalt_size = sizeof (tc_t); break;
10383 case 6600: esalt_size = sizeof (agilekey_t); break;
10384 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10385 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10386 case 7300: esalt_size = sizeof (rakp_t); break;
10387 case 7500: esalt_size = sizeof (krb5pa_t); break;
10388 case 8200: esalt_size = sizeof (cloudkey_t); break;
10389 case 8800: esalt_size = sizeof (androidfde_t); break;
10390 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10391 case 9400: esalt_size = sizeof (office2007_t); break;
10392 case 9500: esalt_size = sizeof (office2010_t); break;
10393 case 9600: esalt_size = sizeof (office2013_t); break;
10394 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10395 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10396 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10397 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10398 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10399 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10400 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10401 case 10200: esalt_size = sizeof (cram_md5_t); break;
10402 case 10400: esalt_size = sizeof (pdf_t); break;
10403 case 10410: esalt_size = sizeof (pdf_t); break;
10404 case 10420: esalt_size = sizeof (pdf_t); break;
10405 case 10500: esalt_size = sizeof (pdf_t); break;
10406 case 10600: esalt_size = sizeof (pdf_t); break;
10407 case 10700: esalt_size = sizeof (pdf_t); break;
10408 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10409 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10410 case 11400: esalt_size = sizeof (sip_t); break;
10411 case 11600: esalt_size = sizeof (seven_zip_t); break;
10412 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10413 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10414 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10415 case 13000: esalt_size = sizeof (rar5_t); break;
10416 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10417 case 13400: esalt_size = sizeof (keepass_t); break;
10418 }
10419
10420 data.esalt_size = esalt_size;
10421
10422 /**
10423 * choose dictionary parser
10424 */
10425
10426 if (hash_type == HASH_TYPE_LM)
10427 {
10428 get_next_word_func = get_next_word_lm;
10429 }
10430 else if (opts_type & OPTS_TYPE_PT_UPPER)
10431 {
10432 get_next_word_func = get_next_word_uc;
10433 }
10434 else
10435 {
10436 get_next_word_func = get_next_word_std;
10437 }
10438
10439 /**
10440 * dictstat
10441 */
10442
10443 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10444
10445 #ifdef _POSIX
10446 size_t dictstat_nmemb = 0;
10447 #endif
10448
10449 #ifdef _WIN
10450 uint dictstat_nmemb = 0;
10451 #endif
10452
10453 char dictstat[256] = { 0 };
10454
10455 FILE *dictstat_fp = NULL;
10456
10457 if (keyspace == 0)
10458 {
10459 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
10460
10461 dictstat_fp = fopen (dictstat, "rb");
10462
10463 if (dictstat_fp)
10464 {
10465 #ifdef _POSIX
10466 struct stat tmpstat;
10467
10468 fstat (fileno (dictstat_fp), &tmpstat);
10469 #endif
10470
10471 #ifdef _WIN
10472 struct stat64 tmpstat;
10473
10474 _fstat64 (fileno (dictstat_fp), &tmpstat);
10475 #endif
10476
10477 if (tmpstat.st_mtime < COMPTIME)
10478 {
10479 /* with v0.15 the format changed so we have to ensure user is using a good version
10480 since there is no version-header in the dictstat file */
10481
10482 fclose (dictstat_fp);
10483
10484 unlink (dictstat);
10485 }
10486 else
10487 {
10488 while (!feof (dictstat_fp))
10489 {
10490 dictstat_t d;
10491
10492 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10493
10494 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10495
10496 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10497 {
10498 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10499
10500 return -1;
10501 }
10502 }
10503
10504 fclose (dictstat_fp);
10505 }
10506 }
10507 }
10508
10509 /**
10510 * potfile
10511 */
10512
10513 char potfile[256] = { 0 };
10514
10515 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
10516
10517 data.pot_fp = NULL;
10518
10519 FILE *out_fp = NULL;
10520 FILE *pot_fp = NULL;
10521
10522 if (show == 1 || left == 1)
10523 {
10524 pot_fp = fopen (potfile, "rb");
10525
10526 if (pot_fp == NULL)
10527 {
10528 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10529
10530 return (-1);
10531 }
10532
10533 if (outfile != NULL)
10534 {
10535 if ((out_fp = fopen (outfile, "ab")) == NULL)
10536 {
10537 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10538
10539 fclose (pot_fp);
10540
10541 return (-1);
10542 }
10543 }
10544 else
10545 {
10546 out_fp = stdout;
10547 }
10548 }
10549 else
10550 {
10551 if (potfile_disable == 0)
10552 {
10553 pot_fp = fopen (potfile, "ab");
10554
10555 if (pot_fp == NULL)
10556 {
10557 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10558
10559 return (-1);
10560 }
10561
10562 data.pot_fp = pot_fp;
10563 }
10564 }
10565
10566 pot_t *pot = NULL;
10567
10568 uint pot_cnt = 0;
10569 uint pot_avail = 0;
10570
10571 if (show == 1 || left == 1)
10572 {
10573 SUPPRESS_OUTPUT = 1;
10574
10575 pot_avail = count_lines (pot_fp);
10576
10577 rewind (pot_fp);
10578
10579 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10580
10581 uint pot_hashes_avail = 0;
10582
10583 uint line_num = 0;
10584
10585 char *line_buf = (char *) mymalloc (HCBUFSIZ);
10586
10587 while (!feof (pot_fp))
10588 {
10589 line_num++;
10590
10591 int line_len = fgetl (pot_fp, line_buf);
10592
10593 if (line_len == 0) continue;
10594
10595 char *plain_buf = line_buf + line_len;
10596
10597 pot_t *pot_ptr = &pot[pot_cnt];
10598
10599 hash_t *hashes_buf = &pot_ptr->hash;
10600
10601 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10602 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10603
10604 if (pot_cnt == pot_hashes_avail)
10605 {
10606 uint pos = 0;
10607
10608 for (pos = 0; pos < INCR_POT; pos++)
10609 {
10610 if ((pot_cnt + pos) >= pot_avail) break;
10611
10612 pot_t *tmp_pot = &pot[pot_cnt + pos];
10613
10614 hash_t *tmp_hash = &tmp_pot->hash;
10615
10616 tmp_hash->digest = mymalloc (dgst_size);
10617
10618 if (isSalted)
10619 {
10620 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10621 }
10622
10623 if (esalt_size)
10624 {
10625 tmp_hash->esalt = mymalloc (esalt_size);
10626 }
10627
10628 pot_hashes_avail++;
10629 }
10630 }
10631
10632 int plain_len = 0;
10633
10634 int parser_status;
10635
10636 int iter = MAX_CUT_TRIES;
10637
10638 do
10639 {
10640 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10641 {
10642 if (line_buf[i] == ':')
10643 {
10644 line_len--;
10645
10646 break;
10647 }
10648 }
10649
10650 if (data.hash_mode != 2500)
10651 {
10652 parser_status = parse_func (line_buf, line_len, hashes_buf);
10653 }
10654 else
10655 {
10656 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10657
10658 if (line_len > max_salt_size)
10659 {
10660 parser_status = PARSER_GLOBAL_LENGTH;
10661 }
10662 else
10663 {
10664 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10665
10666 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10667
10668 hashes_buf->salt->salt_len = line_len;
10669
10670 parser_status = PARSER_OK;
10671 }
10672 }
10673
10674 // if NOT parsed without error, we add the ":" to the plain
10675
10676 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10677 {
10678 plain_len++;
10679 plain_buf--;
10680 }
10681
10682 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10683
10684 if (parser_status < PARSER_GLOBAL_ZERO)
10685 {
10686 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10687
10688 continue;
10689 }
10690
10691 if (plain_len >= 255) continue;
10692
10693 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10694
10695 pot_ptr->plain_len = plain_len;
10696
10697 pot_cnt++;
10698 }
10699
10700 myfree (line_buf);
10701
10702 fclose (pot_fp);
10703
10704 SUPPRESS_OUTPUT = 0;
10705
10706 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10707 }
10708
10709 /**
10710 * word len
10711 */
10712
10713 uint pw_min = PW_MIN;
10714 uint pw_max = PW_MAX;
10715
10716 switch (hash_mode)
10717 {
10718 case 125: if (pw_max > 32) pw_max = 32;
10719 break;
10720 case 400: if (pw_max > 40) pw_max = 40;
10721 break;
10722 case 500: if (pw_max > 16) pw_max = 16;
10723 break;
10724 case 1500: if (pw_max > 8) pw_max = 8;
10725 break;
10726 case 1600: if (pw_max > 16) pw_max = 16;
10727 break;
10728 case 1800: if (pw_max > 16) pw_max = 16;
10729 break;
10730 case 2100: if (pw_max > 16) pw_max = 16;
10731 break;
10732 case 2500: if (pw_min < 8) pw_min = 8;
10733 break;
10734 case 3000: if (pw_max > 7) pw_max = 7;
10735 break;
10736 case 5200: if (pw_max > 24) pw_max = 24;
10737 break;
10738 case 5800: if (pw_max > 16) pw_max = 16;
10739 break;
10740 case 6300: if (pw_max > 16) pw_max = 16;
10741 break;
10742 case 7400: if (pw_max > 16) pw_max = 16;
10743 break;
10744 case 7900: if (pw_max > 48) pw_max = 48;
10745 break;
10746 case 8500: if (pw_max > 8) pw_max = 8;
10747 break;
10748 case 8600: if (pw_max > 16) pw_max = 16;
10749 break;
10750 case 9710: pw_min = 5;
10751 pw_max = 5;
10752 break;
10753 case 9810: pw_min = 5;
10754 pw_max = 5;
10755 break;
10756 case 10410: pw_min = 5;
10757 pw_max = 5;
10758 break;
10759 case 10300: if (pw_max < 3) pw_min = 3;
10760 if (pw_max > 40) pw_max = 40;
10761 break;
10762 case 10500: if (pw_max < 3) pw_min = 3;
10763 if (pw_max > 40) pw_max = 40;
10764 break;
10765 case 10700: if (pw_max > 16) pw_max = 16;
10766 break;
10767 case 11300: if (pw_max > 40) pw_max = 40;
10768 break;
10769 case 12500: if (pw_max > 20) pw_max = 20;
10770 break;
10771 case 12800: if (pw_max > 24) pw_max = 24;
10772 break;
10773 }
10774
10775 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10776 {
10777 switch (attack_kern)
10778 {
10779 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10780 break;
10781 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10782 break;
10783 }
10784 }
10785
10786 /**
10787 * charsets : keep them together for more easy maintainnce
10788 */
10789
10790 cs_t mp_sys[6] = { { { 0 }, 0 } };
10791 cs_t mp_usr[4] = { { { 0 }, 0 } };
10792
10793 mp_setup_sys (mp_sys);
10794
10795 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10796 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10797 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10798 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10799
10800 /**
10801 * load hashes, part I: find input mode, count hashes
10802 */
10803
10804 uint hashlist_mode = 0;
10805 uint hashlist_format = HLFMT_HASHCAT;
10806
10807 uint hashes_avail = 0;
10808
10809 if (benchmark == 0)
10810 {
10811 struct stat f;
10812
10813 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10814
10815 if ((hash_mode == 2500) ||
10816 (hash_mode == 5200) ||
10817 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10818 (hash_mode == 9000))
10819 {
10820 hashlist_mode = HL_MODE_ARG;
10821
10822 char *hashfile = myargv[optind];
10823
10824 data.hashfile = hashfile;
10825
10826 logfile_top_var_string ("target", hashfile);
10827 }
10828
10829 if (hashlist_mode == HL_MODE_ARG)
10830 {
10831 if (hash_mode == 2500)
10832 {
10833 struct stat st;
10834
10835 if (stat (data.hashfile, &st) == -1)
10836 {
10837 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10838
10839 return (-1);
10840 }
10841
10842 hashes_avail = st.st_size / sizeof (hccap_t);
10843 }
10844 else
10845 {
10846 hashes_avail = 1;
10847 }
10848 }
10849 else if (hashlist_mode == HL_MODE_FILE)
10850 {
10851 char *hashfile = myargv[optind];
10852
10853 data.hashfile = hashfile;
10854
10855 logfile_top_var_string ("target", hashfile);
10856
10857 FILE *fp = NULL;
10858
10859 if ((fp = fopen (hashfile, "rb")) == NULL)
10860 {
10861 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10862
10863 return (-1);
10864 }
10865
10866 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10867
10868 hashes_avail = count_lines (fp);
10869
10870 rewind (fp);
10871
10872 if (hashes_avail == 0)
10873 {
10874 log_error ("ERROR: hashfile is empty or corrupt");
10875
10876 fclose (fp);
10877
10878 return (-1);
10879 }
10880
10881 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10882
10883 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10884 {
10885 log_error ("ERROR: remove not supported in native hashfile-format mode");
10886
10887 fclose (fp);
10888
10889 return (-1);
10890 }
10891
10892 fclose (fp);
10893 }
10894 }
10895 else
10896 {
10897 hashlist_mode = HL_MODE_ARG;
10898
10899 hashes_avail = 1;
10900 }
10901
10902 if (hash_mode == 3000) hashes_avail *= 2;
10903
10904 data.hashlist_mode = hashlist_mode;
10905 data.hashlist_format = hashlist_format;
10906
10907 logfile_top_uint (hashlist_mode);
10908 logfile_top_uint (hashlist_format);
10909
10910 /**
10911 * load hashes, part II: allocate required memory, set pointers
10912 */
10913
10914 hash_t *hashes_buf = NULL;
10915 void *digests_buf = NULL;
10916 salt_t *salts_buf = NULL;
10917 void *esalts_buf = NULL;
10918
10919 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10920
10921 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10922
10923 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10924 {
10925 u32 hash_pos;
10926
10927 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10928 {
10929 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10930
10931 hashes_buf[hash_pos].hash_info = hash_info;
10932
10933 if (username && (remove || show || left))
10934 {
10935 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10936 }
10937
10938 if (benchmark)
10939 {
10940 hash_info->orighash = (char *) mymalloc (256);
10941 }
10942 }
10943 }
10944
10945 if (isSalted)
10946 {
10947 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10948
10949 if (esalt_size)
10950 {
10951 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10952 }
10953 }
10954 else
10955 {
10956 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10957 }
10958
10959 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10960 {
10961 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10962
10963 if (isSalted)
10964 {
10965 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10966
10967 if (esalt_size)
10968 {
10969 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10970 }
10971 }
10972 else
10973 {
10974 hashes_buf[hash_pos].salt = &salts_buf[0];
10975 }
10976 }
10977
10978 /**
10979 * load hashes, part III: parse hashes or generate them if benchmark
10980 */
10981
10982 uint hashes_cnt = 0;
10983
10984 if (benchmark == 0)
10985 {
10986 if (keyspace == 1)
10987 {
10988 // useless to read hash file for keyspace, cheat a little bit w/ optind
10989 }
10990 else if (hashes_avail == 0)
10991 {
10992 }
10993 else if (hashlist_mode == HL_MODE_ARG)
10994 {
10995 char *input_buf = myargv[optind];
10996
10997 uint input_len = strlen (input_buf);
10998
10999 logfile_top_var_string ("target", input_buf);
11000
11001 char *hash_buf = NULL;
11002 int hash_len = 0;
11003
11004 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11005
11006 bool hash_fmt_error = 0;
11007
11008 if (hash_len < 1) hash_fmt_error = 1;
11009 if (hash_buf == NULL) hash_fmt_error = 1;
11010
11011 if (hash_fmt_error)
11012 {
11013 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11014 }
11015 else
11016 {
11017 if (opts_type & OPTS_TYPE_HASH_COPY)
11018 {
11019 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11020
11021 hash_info_tmp->orighash = mystrdup (hash_buf);
11022 }
11023
11024 if (isSalted)
11025 {
11026 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11027 }
11028
11029 int parser_status = PARSER_OK;
11030
11031 if (hash_mode == 2500)
11032 {
11033 if (hash_len == 0)
11034 {
11035 log_error ("ERROR: hccap file not specified");
11036
11037 return (-1);
11038 }
11039
11040 hashlist_mode = HL_MODE_FILE;
11041
11042 data.hashlist_mode = hashlist_mode;
11043
11044 FILE *fp = fopen (hash_buf, "rb");
11045
11046 if (fp == NULL)
11047 {
11048 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11049
11050 return (-1);
11051 }
11052
11053 if (hashes_avail < 1)
11054 {
11055 log_error ("ERROR: hccap file is empty or corrupt");
11056
11057 fclose (fp);
11058
11059 return (-1);
11060 }
11061
11062 uint hccap_size = sizeof (hccap_t);
11063
11064 char *in = (char *) mymalloc (hccap_size);
11065
11066 while (!feof (fp))
11067 {
11068 int n = fread (in, hccap_size, 1, fp);
11069
11070 if (n != 1)
11071 {
11072 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11073
11074 break;
11075 }
11076
11077 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11078
11079 if (parser_status != PARSER_OK)
11080 {
11081 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11082
11083 continue;
11084 }
11085
11086 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11087
11088 if ((show == 1) || (left == 1))
11089 {
11090 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11091
11092 char *salt_ptr = (char *) tmp_salt->salt_buf;
11093
11094 int cur_pos = tmp_salt->salt_len;
11095 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11096
11097 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11098
11099 u8 *pke_ptr = (u8 *) wpa->pke;
11100
11101 // do the appending task
11102
11103 snprintf (salt_ptr + cur_pos,
11104 rem_len,
11105 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11106 pke_ptr[20], pke_ptr[27], pke_ptr[26], pke_ptr[25], pke_ptr[24], pke_ptr[31], // MAC1
11107 pke_ptr[30], pke_ptr[29], pke_ptr[28], pke_ptr[35], pke_ptr[34], pke_ptr[33]); // MAC2
11108
11109
11110 // memset () the remaining part of the salt
11111
11112 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11113 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11114
11115 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11116
11117 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11118 }
11119
11120 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);
11121 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);
11122
11123 hashes_cnt++;
11124 }
11125
11126 fclose (fp);
11127
11128 myfree (in);
11129 }
11130 else if (hash_mode == 3000)
11131 {
11132 if (hash_len == 32)
11133 {
11134 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11135
11136 hash_t *lm_hash_left = NULL;
11137
11138 if (parser_status == PARSER_OK)
11139 {
11140 lm_hash_left = &hashes_buf[hashes_cnt];
11141
11142 hashes_cnt++;
11143 }
11144 else
11145 {
11146 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11147 }
11148
11149 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11150
11151 hash_t *lm_hash_right = NULL;
11152
11153 if (parser_status == PARSER_OK)
11154 {
11155 lm_hash_right = &hashes_buf[hashes_cnt];
11156
11157 hashes_cnt++;
11158 }
11159 else
11160 {
11161 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11162 }
11163
11164 // show / left
11165
11166 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11167 {
11168 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);
11169 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);
11170 }
11171 }
11172 else
11173 {
11174 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11175
11176 if (parser_status == PARSER_OK)
11177 {
11178 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11179 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11180 }
11181
11182 if (parser_status == PARSER_OK)
11183 {
11184 hashes_cnt++;
11185 }
11186 else
11187 {
11188 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11189 }
11190 }
11191 }
11192 else
11193 {
11194 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11195
11196 if (parser_status == PARSER_OK)
11197 {
11198 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11199 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11200 }
11201
11202 if (parser_status == PARSER_OK)
11203 {
11204 hashes_cnt++;
11205 }
11206 else
11207 {
11208 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11209 }
11210 }
11211 }
11212 }
11213 else if (hashlist_mode == HL_MODE_FILE)
11214 {
11215 char *hashfile = data.hashfile;
11216
11217 FILE *fp;
11218
11219 if ((fp = fopen (hashfile, "rb")) == NULL)
11220 {
11221 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11222
11223 return (-1);
11224 }
11225
11226 uint line_num = 0;
11227
11228 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11229
11230 while (!feof (fp))
11231 {
11232 line_num++;
11233
11234 int line_len = fgetl (fp, line_buf);
11235
11236 if (line_len == 0) continue;
11237
11238 char *hash_buf = NULL;
11239 int hash_len = 0;
11240
11241 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11242
11243 bool hash_fmt_error = 0;
11244
11245 if (hash_len < 1) hash_fmt_error = 1;
11246 if (hash_buf == NULL) hash_fmt_error = 1;
11247
11248 if (hash_fmt_error)
11249 {
11250 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11251
11252 continue;
11253 }
11254
11255 if (username)
11256 {
11257 char *user_buf = NULL;
11258 int user_len = 0;
11259
11260 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11261
11262 if (remove || show)
11263 {
11264 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11265
11266 *user = (user_t *) mymalloc (sizeof (user_t));
11267
11268 user_t *user_ptr = *user;
11269
11270 if (user_buf != NULL)
11271 {
11272 user_ptr->user_name = mystrdup (user_buf);
11273 }
11274 else
11275 {
11276 user_ptr->user_name = mystrdup ("");
11277 }
11278
11279 user_ptr->user_len = user_len;
11280 }
11281 }
11282
11283 if (opts_type & OPTS_TYPE_HASH_COPY)
11284 {
11285 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11286
11287 hash_info_tmp->orighash = mystrdup (hash_buf);
11288 }
11289
11290 if (isSalted)
11291 {
11292 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11293 }
11294
11295 if (hash_mode == 3000)
11296 {
11297 if (hash_len == 32)
11298 {
11299 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11300
11301 if (parser_status < PARSER_GLOBAL_ZERO)
11302 {
11303 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11304
11305 continue;
11306 }
11307
11308 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11309
11310 hashes_cnt++;
11311
11312 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11313
11314 if (parser_status < PARSER_GLOBAL_ZERO)
11315 {
11316 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11317
11318 continue;
11319 }
11320
11321 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11322
11323 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);
11324
11325 hashes_cnt++;
11326
11327 // show / left
11328
11329 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);
11330 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);
11331 }
11332 else
11333 {
11334 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11335
11336 if (parser_status < PARSER_GLOBAL_ZERO)
11337 {
11338 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11339
11340 continue;
11341 }
11342
11343 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);
11344
11345 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11346 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11347
11348 hashes_cnt++;
11349 }
11350 }
11351 else
11352 {
11353 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11354
11355 if (parser_status < PARSER_GLOBAL_ZERO)
11356 {
11357 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11358
11359 continue;
11360 }
11361
11362 if (data.quiet == 0) if ((hashes_cnt % 0x20000) == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_cnt, hashes_avail, ((float) hashes_cnt / hashes_avail) * 100);
11363
11364 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11365 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11366
11367 hashes_cnt++;
11368 }
11369 }
11370
11371 myfree (line_buf);
11372
11373 fclose (fp);
11374
11375 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11376
11377 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11378 }
11379 }
11380 else
11381 {
11382 if (isSalted)
11383 {
11384 hashes_buf[0].salt->salt_len = 8;
11385
11386 // special salt handling
11387
11388 switch (hash_mode)
11389 {
11390 case 1500: hashes_buf[0].salt->salt_len = 2;
11391 break;
11392 case 1731: hashes_buf[0].salt->salt_len = 4;
11393 break;
11394 case 2410: hashes_buf[0].salt->salt_len = 4;
11395 break;
11396 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11397 break;
11398 case 3100: hashes_buf[0].salt->salt_len = 1;
11399 break;
11400 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11401 break;
11402 case 5800: hashes_buf[0].salt->salt_len = 16;
11403 break;
11404 case 6800: hashes_buf[0].salt->salt_len = 32;
11405 break;
11406 case 8400: hashes_buf[0].salt->salt_len = 40;
11407 break;
11408 case 8800: hashes_buf[0].salt->salt_len = 16;
11409 break;
11410 case 8900: hashes_buf[0].salt->salt_len = 16;
11411 hashes_buf[0].salt->scrypt_N = 1024;
11412 hashes_buf[0].salt->scrypt_r = 1;
11413 hashes_buf[0].salt->scrypt_p = 1;
11414 break;
11415 case 9100: hashes_buf[0].salt->salt_len = 16;
11416 break;
11417 case 9300: hashes_buf[0].salt->salt_len = 14;
11418 hashes_buf[0].salt->scrypt_N = 16384;
11419 hashes_buf[0].salt->scrypt_r = 1;
11420 hashes_buf[0].salt->scrypt_p = 1;
11421 break;
11422 case 9400: hashes_buf[0].salt->salt_len = 16;
11423 break;
11424 case 9500: hashes_buf[0].salt->salt_len = 16;
11425 break;
11426 case 9600: hashes_buf[0].salt->salt_len = 16;
11427 break;
11428 case 9700: hashes_buf[0].salt->salt_len = 16;
11429 break;
11430 case 9710: hashes_buf[0].salt->salt_len = 16;
11431 break;
11432 case 9720: hashes_buf[0].salt->salt_len = 16;
11433 break;
11434 case 9800: hashes_buf[0].salt->salt_len = 16;
11435 break;
11436 case 9810: hashes_buf[0].salt->salt_len = 16;
11437 break;
11438 case 9820: hashes_buf[0].salt->salt_len = 16;
11439 break;
11440 case 10300: hashes_buf[0].salt->salt_len = 12;
11441 break;
11442 case 11500: hashes_buf[0].salt->salt_len = 4;
11443 break;
11444 case 11600: hashes_buf[0].salt->salt_len = 4;
11445 break;
11446 case 12400: hashes_buf[0].salt->salt_len = 4;
11447 break;
11448 case 12500: hashes_buf[0].salt->salt_len = 8;
11449 break;
11450 case 12600: hashes_buf[0].salt->salt_len = 64;
11451 break;
11452 }
11453
11454 // special esalt handling
11455
11456 switch (hash_mode)
11457 {
11458 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11459 break;
11460 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11461 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11462 break;
11463 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11464 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11465 break;
11466 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11467 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11468 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11469 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11470 break;
11471 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11472 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11473 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11474 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11475 break;
11476 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11477 break;
11478 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11479 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11480 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11481 break;
11482 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11483 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11484 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11485 break;
11486 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11487 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11488 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11489 break;
11490 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11491 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11492 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11493 break;
11494 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11495 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11496 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11497 break;
11498 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11499 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11500 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11501 break;
11502 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11503 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11504 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11505 break;
11506 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
11507 break;
11508 }
11509 }
11510
11511 // set hashfile
11512
11513 switch (hash_mode)
11514 {
11515 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11516 break;
11517 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11518 break;
11519 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11520 break;
11521 case 6211: data.hashfile = mystrdup ("hashcat.tc");
11522 break;
11523 case 6212: data.hashfile = mystrdup ("hashcat.tc");
11524 break;
11525 case 6213: data.hashfile = mystrdup ("hashcat.tc");
11526 break;
11527 case 6221: data.hashfile = mystrdup ("hashcat.tc");
11528 break;
11529 case 6222: data.hashfile = mystrdup ("hashcat.tc");
11530 break;
11531 case 6223: data.hashfile = mystrdup ("hashcat.tc");
11532 break;
11533 case 6231: data.hashfile = mystrdup ("hashcat.tc");
11534 break;
11535 case 6232: data.hashfile = mystrdup ("hashcat.tc");
11536 break;
11537 case 6233: data.hashfile = mystrdup ("hashcat.tc");
11538 break;
11539 case 6241: data.hashfile = mystrdup ("hashcat.tc");
11540 break;
11541 case 6242: data.hashfile = mystrdup ("hashcat.tc");
11542 break;
11543 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11544 break;
11545 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11546 break;
11547 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11548 break;
11549 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11550 break;
11551 }
11552
11553 // set default iterations
11554
11555 switch (hash_mode)
11556 {
11557 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11558 break;
11559 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11560 break;
11561 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11562 break;
11563 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11564 break;
11565 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11566 break;
11567 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11568 break;
11569 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11570 break;
11571 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11572 break;
11573 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11574 break;
11575 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11576 break;
11577 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11578 break;
11579 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11580 break;
11581 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11582 break;
11583 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11584 break;
11585 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11586 break;
11587 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11588 break;
11589 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11590 break;
11591 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11592 break;
11593 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11594 break;
11595 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11596 break;
11597 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11598 break;
11599 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11600 break;
11601 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11602 break;
11603 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11604 break;
11605 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11606 break;
11607 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11608 break;
11609 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11610 break;
11611 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11612 break;
11613 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11614 break;
11615 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11616 break;
11617 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11618 break;
11619 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11620 break;
11621 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11622 break;
11623 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11624 break;
11625 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11626 break;
11627 case 8900: hashes_buf[0].salt->salt_iter = 1;
11628 break;
11629 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11630 break;
11631 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11632 break;
11633 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11634 break;
11635 case 9300: hashes_buf[0].salt->salt_iter = 1;
11636 break;
11637 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11638 break;
11639 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11640 break;
11641 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11642 break;
11643 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11644 break;
11645 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11646 break;
11647 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11648 break;
11649 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11650 break;
11651 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11652 break;
11653 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11654 break;
11655 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11656 break;
11657 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11658 break;
11659 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11660 break;
11661 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11662 break;
11663 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11664 break;
11665 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11666 break;
11667 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11668 break;
11669 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11670 break;
11671 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11672 break;
11673 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11674 break;
11675 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11676 break;
11677 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11678 break;
11679 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
11680 break;
11681 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
11682 break;
11683 }
11684
11685 hashes_cnt = 1;
11686 }
11687
11688 if (show == 1 || left == 1)
11689 {
11690 for (uint i = 0; i < pot_cnt; i++)
11691 {
11692 pot_t *pot_ptr = &pot[i];
11693
11694 hash_t *hashes_buf = &pot_ptr->hash;
11695
11696 local_free (hashes_buf->digest);
11697
11698 if (isSalted)
11699 {
11700 local_free (hashes_buf->salt);
11701 }
11702 }
11703
11704 local_free (pot);
11705
11706 if (data.quiet == 0) log_info_nn ("");
11707
11708 return (0);
11709 }
11710
11711 if (keyspace == 0)
11712 {
11713 if (hashes_cnt == 0)
11714 {
11715 log_error ("ERROR: No hashes loaded");
11716
11717 return (-1);
11718 }
11719 }
11720
11721 /**
11722 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11723 */
11724
11725 if (data.outfile != NULL)
11726 {
11727 if (data.hashfile != NULL)
11728 {
11729 #ifdef _POSIX
11730 struct stat tmpstat_outfile;
11731 struct stat tmpstat_hashfile;
11732 #endif
11733
11734 #ifdef _WIN
11735 struct stat64 tmpstat_outfile;
11736 struct stat64 tmpstat_hashfile;
11737 #endif
11738
11739 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11740
11741 if (tmp_outfile_fp)
11742 {
11743 #ifdef _POSIX
11744 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11745 #endif
11746
11747 #ifdef _WIN
11748 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11749 #endif
11750
11751 fclose (tmp_outfile_fp);
11752 }
11753
11754 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11755
11756 if (tmp_hashfile_fp)
11757 {
11758 #ifdef _POSIX
11759 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11760 #endif
11761
11762 #ifdef _WIN
11763 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11764 #endif
11765
11766 fclose (tmp_hashfile_fp);
11767 }
11768
11769 if (tmp_outfile_fp && tmp_outfile_fp)
11770 {
11771 tmpstat_outfile.st_mode = 0;
11772 tmpstat_outfile.st_nlink = 0;
11773 tmpstat_outfile.st_uid = 0;
11774 tmpstat_outfile.st_gid = 0;
11775 tmpstat_outfile.st_rdev = 0;
11776 tmpstat_outfile.st_atime = 0;
11777
11778 tmpstat_hashfile.st_mode = 0;
11779 tmpstat_hashfile.st_nlink = 0;
11780 tmpstat_hashfile.st_uid = 0;
11781 tmpstat_hashfile.st_gid = 0;
11782 tmpstat_hashfile.st_rdev = 0;
11783 tmpstat_hashfile.st_atime = 0;
11784
11785 #ifdef _POSIX
11786 tmpstat_outfile.st_blksize = 0;
11787 tmpstat_outfile.st_blocks = 0;
11788
11789 tmpstat_hashfile.st_blksize = 0;
11790 tmpstat_hashfile.st_blocks = 0;
11791 #endif
11792
11793 #ifdef _POSIX
11794 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11795 {
11796 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11797
11798 return (-1);
11799 }
11800 #endif
11801
11802 #ifdef _WIN
11803 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11804 {
11805 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11806
11807 return (-1);
11808 }
11809 #endif
11810 }
11811 }
11812 }
11813
11814 /**
11815 * Remove duplicates
11816 */
11817
11818 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11819
11820 if (isSalted)
11821 {
11822 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11823 }
11824 else
11825 {
11826 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11827 }
11828
11829 uint hashes_cnt_orig = hashes_cnt;
11830
11831 hashes_cnt = 1;
11832
11833 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11834 {
11835 if (isSalted)
11836 {
11837 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11838 {
11839 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11840 }
11841 }
11842 else
11843 {
11844 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11845 }
11846
11847 if (hashes_pos > hashes_cnt)
11848 {
11849 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11850 }
11851
11852 hashes_cnt++;
11853 }
11854
11855 /**
11856 * Potfile removes
11857 */
11858
11859 uint potfile_remove_cracks = 0;
11860
11861 if (potfile_disable == 0)
11862 {
11863 hash_t hash_buf;
11864
11865 hash_buf.digest = mymalloc (dgst_size);
11866 hash_buf.salt = NULL;
11867 hash_buf.esalt = NULL;
11868 hash_buf.hash_info = NULL;
11869 hash_buf.cracked = 0;
11870
11871 if (isSalted)
11872 {
11873 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11874 }
11875
11876 if (esalt_size)
11877 {
11878 hash_buf.esalt = mymalloc (esalt_size);
11879 }
11880
11881 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11882
11883 // no solution for these special hash types (for instane because they use hashfile in output etc)
11884 if ((hash_mode != 5200) &&
11885 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11886 (hash_mode != 9000))
11887 {
11888 FILE *fp = fopen (potfile, "rb");
11889
11890 if (fp != NULL)
11891 {
11892 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11893
11894 // to be safe work with a copy (because of line_len loop, i etc)
11895 // moved up here because it's easier to handle continue case
11896 // it's just 64kb
11897
11898 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
11899
11900 while (!feof (fp))
11901 {
11902 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
11903
11904 if (ptr == NULL) break;
11905
11906 int line_len = strlen (line_buf);
11907
11908 if (line_len == 0) continue;
11909
11910 int iter = MAX_CUT_TRIES;
11911
11912 for (int i = line_len - 1; i && iter; i--, line_len--)
11913 {
11914 if (line_buf[i] != ':') continue;
11915
11916 if (isSalted)
11917 {
11918 memset (hash_buf.salt, 0, sizeof (salt_t));
11919 }
11920
11921 hash_t *found = NULL;
11922
11923 if (hash_mode == 6800)
11924 {
11925 if (i < 64) // 64 = 16 * uint in salt_buf[]
11926 {
11927 // manipulate salt_buf
11928 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11929
11930 hash_buf.salt->salt_len = i;
11931
11932 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11933 }
11934 }
11935 else if (hash_mode == 2500)
11936 {
11937 if (i < 64) // 64 = 16 * uint in salt_buf[]
11938 {
11939 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11940 // manipulate salt_buf
11941
11942 memcpy (line_buf_cpy, line_buf, i);
11943
11944 char *mac2_pos = strrchr (line_buf_cpy, ':');
11945
11946 if (mac2_pos == NULL) continue;
11947
11948 mac2_pos[0] = 0;
11949 mac2_pos++;
11950
11951 if (strlen (mac2_pos) != 12) continue;
11952
11953 char *mac1_pos = strrchr (line_buf_cpy, ':');
11954
11955 if (mac1_pos == NULL) continue;
11956
11957 mac1_pos[0] = 0;
11958 mac1_pos++;
11959
11960 if (strlen (mac1_pos) != 12) continue;
11961
11962 uint essid_length = mac1_pos - line_buf_cpy - 1;
11963
11964 // here we need the ESSID
11965 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11966
11967 hash_buf.salt->salt_len = essid_length;
11968
11969 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11970
11971 if (found)
11972 {
11973 wpa_t *wpa = (wpa_t *) found->esalt;
11974
11975 uint pke[25] = { 0 };
11976
11977 char *pke_ptr = (char *) pke;
11978
11979 for (uint i = 0; i < 25; i++)
11980 {
11981 pke[i] = byte_swap_32 (wpa->pke[i]);
11982 }
11983
11984 u8 mac1[6] = { 0 };
11985 u8 mac2[6] = { 0 };
11986
11987 memcpy (mac1, pke_ptr + 23, 6);
11988 memcpy (mac2, pke_ptr + 29, 6);
11989
11990 // compare hex string(s) vs binary MAC address(es)
11991
11992 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11993 {
11994 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
11995 {
11996 found = NULL;
11997 break;
11998 }
11999 }
12000
12001 // early skip ;)
12002 if (!found) continue;
12003
12004 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12005 {
12006 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
12007 {
12008 found = NULL;
12009 break;
12010 }
12011 }
12012 }
12013 }
12014 }
12015 else
12016 {
12017 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12018
12019 if (parser_status == PARSER_OK)
12020 {
12021 if (isSalted)
12022 {
12023 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12024 }
12025 else
12026 {
12027 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12028 }
12029 }
12030 }
12031
12032 if (found == NULL) continue;
12033
12034 if (!found->cracked) potfile_remove_cracks++;
12035
12036 found->cracked = 1;
12037
12038 if (found) break;
12039
12040 iter--;
12041 }
12042 }
12043
12044 myfree (line_buf_cpy);
12045
12046 myfree (line_buf);
12047
12048 fclose (fp);
12049 }
12050 }
12051
12052 if (esalt_size)
12053 {
12054 local_free (hash_buf.esalt);
12055 }
12056
12057 if (isSalted)
12058 {
12059 local_free (hash_buf.salt);
12060 }
12061
12062 local_free (hash_buf.digest);
12063 }
12064
12065 /**
12066 * Now generate all the buffers required for later
12067 */
12068
12069 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12070
12071 salt_t *salts_buf_new = NULL;
12072 void *esalts_buf_new = NULL;
12073
12074 if (isSalted)
12075 {
12076 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12077
12078 if (esalt_size)
12079 {
12080 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12081 }
12082 }
12083 else
12084 {
12085 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12086 }
12087
12088 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12089
12090 uint digests_cnt = hashes_cnt;
12091 uint digests_done = 0;
12092
12093 uint size_digests = digests_cnt * dgst_size;
12094 uint size_shown = digests_cnt * sizeof (uint);
12095
12096 uint *digests_shown = (uint *) mymalloc (size_shown);
12097 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12098
12099 uint salts_cnt = 0;
12100 uint salts_done = 0;
12101
12102 hashinfo_t **hash_info = NULL;
12103
12104 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12105 {
12106 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12107
12108 if (username && (remove || show))
12109 {
12110 uint user_pos;
12111
12112 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12113 {
12114 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12115
12116 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12117 }
12118 }
12119 }
12120
12121 uint *salts_shown = (uint *) mymalloc (size_shown);
12122
12123 salt_t *salt_buf;
12124
12125 {
12126 // copied from inner loop
12127
12128 salt_buf = &salts_buf_new[salts_cnt];
12129
12130 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12131
12132 if (esalt_size)
12133 {
12134 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12135 }
12136
12137 salt_buf->digests_cnt = 0;
12138 salt_buf->digests_done = 0;
12139 salt_buf->digests_offset = 0;
12140
12141 salts_cnt++;
12142 }
12143
12144 if (hashes_buf[0].cracked == 1)
12145 {
12146 digests_shown[0] = 1;
12147
12148 digests_done++;
12149
12150 salt_buf->digests_done++;
12151 }
12152
12153 salt_buf->digests_cnt++;
12154
12155 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12156
12157 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12158 {
12159 hash_info[0] = hashes_buf[0].hash_info;
12160 }
12161
12162 // copy from inner loop
12163
12164 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12165 {
12166 if (isSalted)
12167 {
12168 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12169 {
12170 salt_buf = &salts_buf_new[salts_cnt];
12171
12172 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12173
12174 if (esalt_size)
12175 {
12176 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12177 }
12178
12179 salt_buf->digests_cnt = 0;
12180 salt_buf->digests_done = 0;
12181 salt_buf->digests_offset = hashes_pos;
12182
12183 salts_cnt++;
12184 }
12185 }
12186
12187 if (hashes_buf[hashes_pos].cracked == 1)
12188 {
12189 digests_shown[hashes_pos] = 1;
12190
12191 digests_done++;
12192
12193 salt_buf->digests_done++;
12194 }
12195
12196 salt_buf->digests_cnt++;
12197
12198 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12199
12200 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12201 {
12202 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12203 }
12204 }
12205
12206 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12207 {
12208 salt_t *salt_buf = &salts_buf_new[salt_pos];
12209
12210 if (salt_buf->digests_done == salt_buf->digests_cnt)
12211 {
12212 salts_shown[salt_pos] = 1;
12213
12214 salts_done++;
12215 }
12216
12217 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12218 }
12219
12220 local_free (digests_buf);
12221 local_free (salts_buf);
12222 local_free (esalts_buf);
12223
12224 digests_buf = digests_buf_new;
12225 salts_buf = salts_buf_new;
12226 esalts_buf = esalts_buf_new;
12227
12228 local_free (hashes_buf);
12229
12230 /**
12231 * special modification not set from parser
12232 */
12233
12234 switch (hash_mode)
12235 {
12236 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12237 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12238 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12239 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12240 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12241 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12242 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12243 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12244 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12245 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12246 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12247 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12248 }
12249
12250 if (truecrypt_keyfiles)
12251 {
12252 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12253
12254 char *keyfiles = strdup (truecrypt_keyfiles);
12255
12256 char *keyfile = strtok (keyfiles, ",");
12257
12258 do
12259 {
12260 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12261
12262 } while ((keyfile = strtok (NULL, ",")) != NULL);
12263
12264 free (keyfiles);
12265 }
12266
12267 data.digests_cnt = digests_cnt;
12268 data.digests_done = digests_done;
12269 data.digests_buf = digests_buf;
12270 data.digests_shown = digests_shown;
12271 data.digests_shown_tmp = digests_shown_tmp;
12272
12273 data.salts_cnt = salts_cnt;
12274 data.salts_done = salts_done;
12275 data.salts_buf = salts_buf;
12276 data.salts_shown = salts_shown;
12277
12278 data.esalts_buf = esalts_buf;
12279 data.hash_info = hash_info;
12280
12281 /**
12282 * Automatic Optimizers
12283 */
12284
12285 if (salts_cnt == 1)
12286 opti_type |= OPTI_TYPE_SINGLE_SALT;
12287
12288 if (digests_cnt == 1)
12289 opti_type |= OPTI_TYPE_SINGLE_HASH;
12290
12291 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12292 opti_type |= OPTI_TYPE_NOT_ITERATED;
12293
12294 if (attack_mode == ATTACK_MODE_BF)
12295 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12296
12297 data.opti_type = opti_type;
12298
12299 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12300 {
12301 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12302 {
12303 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12304 {
12305 if (opts_type & OPTS_TYPE_ST_ADD80)
12306 {
12307 opts_type &= ~OPTS_TYPE_ST_ADD80;
12308 opts_type |= OPTS_TYPE_PT_ADD80;
12309 }
12310
12311 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12312 {
12313 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12314 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12315 }
12316
12317 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12318 {
12319 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12320 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12321 }
12322 }
12323 }
12324 }
12325
12326 /**
12327 * Some algorithm, like descrypt, can benefit from JIT compilation
12328 */
12329
12330 int force_jit_compilation = -1;
12331
12332 if (hash_mode == 8900)
12333 {
12334 force_jit_compilation = 8900;
12335 }
12336 else if (hash_mode == 9300)
12337 {
12338 force_jit_compilation = 8900;
12339 }
12340 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12341 {
12342 force_jit_compilation = 1500;
12343 }
12344
12345 /**
12346 * generate bitmap tables
12347 */
12348
12349 const uint bitmap_shift1 = 5;
12350 const uint bitmap_shift2 = 13;
12351
12352 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12353
12354 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12355 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12356 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12357 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12358 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12359 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12360 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12361 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12362
12363 uint bitmap_bits;
12364 uint bitmap_nums;
12365 uint bitmap_mask;
12366 uint bitmap_size;
12367
12368 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12369 {
12370 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12371
12372 bitmap_nums = 1 << bitmap_bits;
12373
12374 bitmap_mask = bitmap_nums - 1;
12375
12376 bitmap_size = bitmap_nums * sizeof (uint);
12377
12378 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12379
12380 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;
12381 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;
12382
12383 break;
12384 }
12385
12386 bitmap_nums = 1 << bitmap_bits;
12387
12388 bitmap_mask = bitmap_nums - 1;
12389
12390 bitmap_size = bitmap_nums * sizeof (uint);
12391
12392 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);
12393 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);
12394
12395 /**
12396 * prepare quick rule
12397 */
12398
12399 data.rule_buf_l = rule_buf_l;
12400 data.rule_buf_r = rule_buf_r;
12401
12402 int rule_len_l = (int) strlen (rule_buf_l);
12403 int rule_len_r = (int) strlen (rule_buf_r);
12404
12405 data.rule_len_l = rule_len_l;
12406 data.rule_len_r = rule_len_r;
12407
12408 /**
12409 * load rules
12410 */
12411
12412 uint *all_kernel_rules_cnt = NULL;
12413
12414 kernel_rule_t **all_kernel_rules_buf = NULL;
12415
12416 if (rp_files_cnt)
12417 {
12418 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12419
12420 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12421 }
12422
12423 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
12424
12425 int rule_len = 0;
12426
12427 for (uint i = 0; i < rp_files_cnt; i++)
12428 {
12429 uint kernel_rules_avail = 0;
12430
12431 uint kernel_rules_cnt = 0;
12432
12433 kernel_rule_t *kernel_rules_buf = NULL;
12434
12435 char *rp_file = rp_files[i];
12436
12437 char in[BLOCK_SIZE] = { 0 };
12438 char out[BLOCK_SIZE] = { 0 };
12439
12440 FILE *fp = NULL;
12441
12442 uint rule_line = 0;
12443
12444 if ((fp = fopen (rp_file, "rb")) == NULL)
12445 {
12446 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12447
12448 return (-1);
12449 }
12450
12451 while (!feof (fp))
12452 {
12453 memset (rule_buf, 0, HCBUFSIZ);
12454
12455 rule_len = fgetl (fp, rule_buf);
12456
12457 rule_line++;
12458
12459 if (rule_len == 0) continue;
12460
12461 if (rule_buf[0] == '#') continue;
12462
12463 if (kernel_rules_avail == kernel_rules_cnt)
12464 {
12465 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12466
12467 kernel_rules_avail += INCR_RULES;
12468 }
12469
12470 memset (in, 0, BLOCK_SIZE);
12471 memset (out, 0, BLOCK_SIZE);
12472
12473 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12474
12475 if (result == -1)
12476 {
12477 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12478
12479 continue;
12480 }
12481
12482 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12483 {
12484 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12485
12486 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12487
12488 continue;
12489 }
12490
12491 /* its so slow
12492 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12493 {
12494 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12495
12496 continue;
12497 }
12498 */
12499
12500 kernel_rules_cnt++;
12501 }
12502
12503 fclose (fp);
12504
12505 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12506
12507 all_kernel_rules_buf[i] = kernel_rules_buf;
12508 }
12509
12510 /**
12511 * merge rules or automatic rule generator
12512 */
12513
12514 uint kernel_rules_cnt = 0;
12515
12516 kernel_rule_t *kernel_rules_buf = NULL;
12517
12518 if (attack_mode == ATTACK_MODE_STRAIGHT)
12519 {
12520 if (rp_files_cnt)
12521 {
12522 kernel_rules_cnt = 1;
12523
12524 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12525
12526 repeats[0] = kernel_rules_cnt;
12527
12528 for (uint i = 0; i < rp_files_cnt; i++)
12529 {
12530 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12531
12532 repeats[i + 1] = kernel_rules_cnt;
12533 }
12534
12535 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12536
12537 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12538
12539 for (uint i = 0; i < kernel_rules_cnt; i++)
12540 {
12541 uint out_pos = 0;
12542
12543 kernel_rule_t *out = &kernel_rules_buf[i];
12544
12545 for (uint j = 0; j < rp_files_cnt; j++)
12546 {
12547 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12548 uint in_pos;
12549
12550 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12551
12552 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12553 {
12554 if (out_pos == RULES_MAX - 1)
12555 {
12556 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12557
12558 break;
12559 }
12560
12561 out->cmds[out_pos] = in->cmds[in_pos];
12562 }
12563 }
12564 }
12565
12566 local_free (repeats);
12567 }
12568 else if (rp_gen)
12569 {
12570 uint kernel_rules_avail = 0;
12571
12572 while (kernel_rules_cnt < rp_gen)
12573 {
12574 if (kernel_rules_avail == kernel_rules_cnt)
12575 {
12576 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12577
12578 kernel_rules_avail += INCR_RULES;
12579 }
12580
12581 memset (rule_buf, 0, HCBUFSIZ);
12582
12583 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12584
12585 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12586
12587 kernel_rules_cnt++;
12588 }
12589 }
12590 }
12591
12592 myfree (rule_buf);
12593
12594 /**
12595 * generate NOP rules
12596 */
12597
12598 if (kernel_rules_cnt == 0)
12599 {
12600 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12601
12602 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12603
12604 kernel_rules_cnt++;
12605 }
12606
12607 data.kernel_rules_cnt = kernel_rules_cnt;
12608 data.kernel_rules_buf = kernel_rules_buf;
12609
12610 /**
12611 * OpenCL platforms: detect
12612 */
12613
12614 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
12615 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
12616
12617 cl_uint platforms_cnt = 0;
12618 cl_uint platform_devices_cnt = 0;
12619
12620 if (keyspace == 0)
12621 {
12622 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12623
12624 if (platforms_cnt == 0)
12625 {
12626 log_error ("ERROR: No OpenCL compatible platform found");
12627
12628 return (-1);
12629 }
12630
12631 if (opencl_platforms_filter != (uint) -1)
12632 {
12633 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
12634
12635 if (opencl_platforms_filter > platform_cnt_mask)
12636 {
12637 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
12638
12639 return (-1);
12640 }
12641 }
12642 }
12643
12644 /**
12645 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12646 */
12647
12648 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12649 {
12650 cl_platform_id platform = platforms[platform_id];
12651
12652 char platform_vendor[INFOSZ] = { 0 };
12653
12654 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12655
12656 #ifdef HAVE_HWMON
12657 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12658 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12659 {
12660 // make sure that we do not directly control the fan for NVidia
12661
12662 gpu_temp_retain = 0;
12663
12664 data.gpu_temp_retain = gpu_temp_retain;
12665 }
12666 #endif // HAVE_NVML || HAVE_NVAPI
12667 #endif
12668 }
12669
12670 /**
12671 * OpenCL devices: simply push all devices from all platforms into the same device array
12672 */
12673
12674 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12675
12676 data.devices_param = devices_param;
12677
12678 uint devices_cnt = 0;
12679
12680 uint devices_active = 0;
12681
12682 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12683 {
12684 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12685
12686 cl_platform_id platform = platforms[platform_id];
12687
12688 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12689
12690 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12691 {
12692 size_t param_value_size = 0;
12693
12694 const uint device_id = devices_cnt;
12695
12696 hc_device_param_t *device_param = &data.devices_param[device_id];
12697
12698 device_param->device = platform_devices[platform_devices_id];
12699
12700 device_param->device_id = device_id;
12701
12702 device_param->platform_devices_id = platform_devices_id;
12703
12704 // device_type
12705
12706 cl_device_type device_type;
12707
12708 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12709
12710 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12711
12712 device_param->device_type = device_type;
12713
12714 // vendor_id
12715
12716 cl_uint vendor_id = 0;
12717
12718 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR_ID, sizeof (vendor_id), &vendor_id, NULL);
12719
12720 device_param->vendor_id = vendor_id;
12721
12722 // device_name
12723
12724 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
12725
12726 char *device_name = (char *) mymalloc (param_value_size);
12727
12728 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
12729
12730 device_param->device_name = device_name;
12731
12732 // tuning db
12733
12734 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
12735
12736 // device_version
12737
12738 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
12739
12740 char *device_version = (char *) mymalloc (param_value_size);
12741
12742 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
12743
12744 device_param->device_version = device_version;
12745
12746 // device_opencl_version
12747
12748 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
12749
12750 char *device_opencl_version = (char *) mymalloc (param_value_size);
12751
12752 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
12753
12754 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
12755
12756 myfree (device_opencl_version);
12757
12758 if (strstr (device_version, "pocl"))
12759 {
12760 // pocl returns the real vendor_id in CL_DEVICE_VENDOR_ID which causes many problems because of hms and missing amd_bfe () etc
12761 // we need to overwrite vendor_id to avoid this. maybe open pocl issue?
12762
12763 cl_uint vendor_id = VENDOR_ID_GENERIC;
12764
12765 device_param->vendor_id = vendor_id;
12766 }
12767
12768 // vector_width
12769
12770 cl_uint vector_width;
12771
12772 if (opencl_vector_width_chgd == 0)
12773 {
12774 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
12775 {
12776 if (opti_type & OPTI_TYPE_USES_BITS_64)
12777 {
12778 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
12779 }
12780 else
12781 {
12782 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12783 }
12784 }
12785 else
12786 {
12787 vector_width = (cl_uint) tuningdb_entry->vector_width;
12788 }
12789 }
12790 else
12791 {
12792 vector_width = opencl_vector_width;
12793 }
12794
12795 if (vector_width > 16) vector_width = 16;
12796
12797 device_param->vector_width = vector_width;
12798
12799 // max_compute_units
12800
12801 cl_uint device_processors;
12802
12803 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12804
12805 device_param->device_processors = device_processors;
12806
12807 // max_mem_alloc_size
12808
12809 cl_ulong device_maxmem_alloc;
12810
12811 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12812
12813 device_param->device_maxmem_alloc = device_maxmem_alloc;
12814
12815 // max_mem_alloc_size
12816
12817 cl_ulong device_global_mem;
12818
12819 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12820
12821 device_param->device_global_mem = device_global_mem;
12822
12823 // max_clock_frequency
12824
12825 cl_uint device_maxclock_frequency;
12826
12827 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12828
12829 device_param->device_maxclock_frequency = device_maxclock_frequency;
12830
12831 // skipped
12832
12833 const u32 skipped1 = ((devices_filter & (1 << device_id)) == 0);
12834 const u32 skipped2 = ((device_types_filter & (device_type)) == 0);
12835
12836 device_param->skipped = (skipped1 || skipped2);
12837
12838 // driver_version
12839 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
12840
12841 char *driver_version = (char *) mymalloc (param_value_size);
12842
12843 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
12844
12845 device_param->driver_version = driver_version;
12846
12847 // device_name_chksum
12848
12849 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12850
12851 #if __x86_64__
12852 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);
12853 #else
12854 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);
12855 #endif
12856
12857 uint device_name_digest[4] = { 0 };
12858
12859 md5_64 ((uint *) device_name_chksum, device_name_digest);
12860
12861 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
12862
12863 device_param->device_name_chksum = device_name_chksum;
12864
12865 // device_processor_cores
12866
12867 if (device_type & CL_DEVICE_TYPE_CPU)
12868 {
12869 cl_uint device_processor_cores = 1;
12870
12871 device_param->device_processor_cores = device_processor_cores;
12872 }
12873
12874 if (device_type & CL_DEVICE_TYPE_GPU)
12875 {
12876 if (vendor_id == VENDOR_ID_AMD)
12877 {
12878 cl_uint device_processor_cores = 0;
12879
12880 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12881
12882 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12883
12884 device_param->device_processor_cores = device_processor_cores;
12885 }
12886 else if (vendor_id == VENDOR_ID_NV)
12887 {
12888 cl_uint kernel_exec_timeout = 0;
12889
12890 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12891
12892 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12893
12894 device_param->kernel_exec_timeout = kernel_exec_timeout;
12895
12896 cl_uint device_processor_cores = 0;
12897
12898 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12899
12900 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12901
12902 device_param->device_processor_cores = device_processor_cores;
12903
12904 cl_uint sm_minor = 0;
12905 cl_uint sm_major = 0;
12906
12907 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12908 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12909
12910 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12911 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12912
12913 device_param->sm_minor = sm_minor;
12914 device_param->sm_major = sm_major;
12915 }
12916 else
12917 {
12918 cl_uint device_processor_cores = 1;
12919
12920 device_param->device_processor_cores = device_processor_cores;
12921 }
12922 }
12923
12924 // display results
12925
12926 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12927 {
12928 if (device_param->skipped == 0)
12929 {
12930 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12931 device_id + 1,
12932 device_name,
12933 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
12934 (unsigned int) (device_global_mem / 1024 / 1024),
12935 (unsigned int) (device_maxclock_frequency),
12936 (unsigned int) device_processors);
12937 }
12938 else
12939 {
12940 log_info ("Device #%u: %s, skipped",
12941 device_id + 1,
12942 device_name);
12943 }
12944 }
12945
12946 // common driver check
12947
12948 if (device_param->skipped == 0)
12949 {
12950 if (strstr (device_version, "pocl"))
12951 {
12952 if (force == 0)
12953 {
12954 log_info ("");
12955 log_info ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
12956 log_info ("You are STRONGLY encouraged not to use it");
12957 log_info ("You can use --force to override this but do not post error reports if you do so");
12958 log_info ("");
12959
12960 return (-1);
12961 }
12962 }
12963
12964 if (device_type & CL_DEVICE_TYPE_GPU)
12965 {
12966 if (vendor_id == VENDOR_ID_NV)
12967 {
12968 if (device_param->kernel_exec_timeout != 0)
12969 {
12970 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);
12971 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12972 }
12973 }
12974 else if (vendor_id == VENDOR_ID_AMD)
12975 {
12976 int catalyst_check = (force == 1) ? 0 : 1;
12977
12978 int catalyst_warn = 0;
12979
12980 int catalyst_broken = 0;
12981
12982 if (catalyst_check == 1)
12983 {
12984 catalyst_warn = 1;
12985
12986 // v14.9 and higher
12987 if (atoi (device_param->driver_version) >= 1573)
12988 {
12989 catalyst_warn = 0;
12990 }
12991
12992 catalyst_check = 0;
12993 }
12994
12995 if (catalyst_broken == 1)
12996 {
12997 log_info ("");
12998 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
12999 log_info ("It will pass over cracked hashes and does not report them as cracked");
13000 log_info ("You are STRONGLY encouraged not to use it");
13001 log_info ("You can use --force to override this but do not post error reports if you do so");
13002 log_info ("");
13003
13004 return (-1);
13005 }
13006
13007 if (catalyst_warn == 1)
13008 {
13009 log_info ("");
13010 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13011 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13012 log_info ("See oclHashcat's homepage for official supported catalyst drivers");
13013 #ifdef _WIN
13014 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13015 #endif
13016 log_info ("You can use --force to override this but do not post error reports if you do so");
13017 log_info ("");
13018
13019 return (-1);
13020 }
13021 }
13022 }
13023
13024 /**
13025 * kernel accel and loops tuning db adjustment
13026 */
13027
13028 device_param->kernel_accel_min = 1;
13029 device_param->kernel_accel_max = 1024;
13030
13031 device_param->kernel_loops_min = 1;
13032 device_param->kernel_loops_max = 1024;
13033
13034 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13035
13036 if (tuningdb_entry)
13037 {
13038 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13039 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13040
13041 if (_kernel_accel)
13042 {
13043 device_param->kernel_accel_min = _kernel_accel;
13044 device_param->kernel_accel_max = _kernel_accel;
13045 }
13046
13047 if (_kernel_loops)
13048 {
13049 if (workload_profile == 1)
13050 {
13051 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13052 }
13053 else if (workload_profile == 2)
13054 {
13055 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13056 }
13057
13058 device_param->kernel_loops_min = _kernel_loops;
13059 device_param->kernel_loops_max = _kernel_loops;
13060 }
13061 }
13062
13063 // commandline parameters overwrite tuningdb entries
13064
13065 if (kernel_accel)
13066 {
13067 device_param->kernel_accel_min = kernel_accel;
13068 device_param->kernel_accel_max = kernel_accel;
13069 }
13070
13071 if (kernel_loops)
13072 {
13073 device_param->kernel_loops_min = kernel_loops;
13074 device_param->kernel_loops_max = kernel_loops;
13075 }
13076
13077 /**
13078 * activate device
13079 */
13080
13081 devices_active++;
13082 }
13083
13084 // next please
13085
13086 devices_cnt++;
13087 }
13088 }
13089
13090 if (keyspace == 0 && devices_active == 0)
13091 {
13092 log_error ("ERROR: No devices found/left");
13093
13094 return (-1);
13095 }
13096
13097 // 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)
13098
13099 if (devices_filter != (uint) -1)
13100 {
13101 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
13102
13103 if (devices_filter > devices_cnt_mask)
13104 {
13105 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
13106
13107 return (-1);
13108 }
13109 }
13110
13111 data.devices_cnt = devices_cnt;
13112
13113 data.devices_active = devices_active;
13114
13115 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13116 {
13117 log_info ("");
13118 }
13119
13120 /**
13121 * HM devices: init
13122 */
13123
13124 #ifdef HAVE_HWMON
13125 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13126 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13127 #endif
13128
13129 #ifdef HAVE_ADL
13130 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13131 #endif
13132
13133 if (gpu_temp_disable == 0)
13134 {
13135 #if defined(WIN) && defined(HAVE_NVAPI)
13136 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13137
13138 if (nvapi_init (nvapi) == 0)
13139 data.hm_nv = nvapi;
13140
13141 if (data.hm_nv)
13142 {
13143 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13144 {
13145 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13146
13147 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13148
13149 int tmp_out = 0;
13150
13151 for (int i = 0; i < tmp_in; i++)
13152 {
13153 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13154 }
13155
13156 for (int i = 0; i < tmp_out; i++)
13157 {
13158 NV_GPU_COOLER_SETTINGS pCoolerSettings;
13159
13160 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
13161
13162 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;
13163 }
13164 }
13165 }
13166 #endif // WIN && HAVE_NVAPI
13167
13168 #if defined(LINUX) && defined(HAVE_NVML)
13169 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13170
13171 if (nvml_init (nvml) == 0)
13172 data.hm_nv = nvml;
13173
13174 if (data.hm_nv)
13175 {
13176 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13177 {
13178 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13179
13180 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13181
13182 int tmp_out = 0;
13183
13184 for (int i = 0; i < tmp_in; i++)
13185 {
13186 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13187 }
13188
13189 for (int i = 0; i < tmp_out; i++)
13190 {
13191 unsigned int speed;
13192
13193 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;
13194 }
13195 }
13196 }
13197 #endif // LINUX && HAVE_NVML
13198
13199 data.hm_amd = NULL;
13200
13201 #ifdef HAVE_ADL
13202 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13203
13204 if (adl_init (adl) == 0)
13205 data.hm_amd = adl;
13206
13207 if (data.hm_amd)
13208 {
13209 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13210 {
13211 // total number of adapters
13212
13213 int hm_adapters_num;
13214
13215 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13216
13217 // adapter info
13218
13219 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13220
13221 if (lpAdapterInfo == NULL) return (-1);
13222
13223 // get a list (of ids of) valid/usable adapters
13224
13225 int num_adl_adapters = 0;
13226
13227 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13228
13229 if (num_adl_adapters > 0)
13230 {
13231 hc_thread_mutex_lock (mux_adl);
13232
13233 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13234
13235 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13236
13237 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13238 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13239
13240 hc_thread_mutex_unlock (mux_adl);
13241 }
13242
13243 myfree (valid_adl_device_list);
13244 myfree (lpAdapterInfo);
13245 }
13246 }
13247 #endif // HAVE_ADL
13248
13249 if (data.hm_amd == NULL && data.hm_nv == NULL)
13250 {
13251 gpu_temp_disable = 1;
13252 }
13253 }
13254
13255 /**
13256 * OpenCL devices: allocate buffer for device specific information
13257 */
13258
13259 #ifdef HAVE_HWMON
13260 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13261
13262 #ifdef HAVE_ADL
13263 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13264
13265 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13266 #endif // ADL
13267 #endif
13268
13269 /**
13270 * enable custom signal handler(s)
13271 */
13272
13273 if (benchmark == 0)
13274 {
13275 hc_signal (sigHandler_default);
13276 }
13277 else
13278 {
13279 hc_signal (sigHandler_benchmark);
13280 }
13281
13282 /**
13283 * User-defined GPU temp handling
13284 */
13285
13286 #ifdef HAVE_HWMON
13287 if (gpu_temp_disable == 1)
13288 {
13289 gpu_temp_abort = 0;
13290 gpu_temp_retain = 0;
13291 }
13292
13293 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13294 {
13295 if (gpu_temp_abort < gpu_temp_retain)
13296 {
13297 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13298
13299 return (-1);
13300 }
13301 }
13302
13303 data.gpu_temp_disable = gpu_temp_disable;
13304 data.gpu_temp_abort = gpu_temp_abort;
13305 data.gpu_temp_retain = gpu_temp_retain;
13306 #endif
13307
13308 /**
13309 * inform the user
13310 */
13311
13312 if (data.quiet == 0)
13313 {
13314 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13315
13316 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);
13317
13318 if (attack_mode == ATTACK_MODE_STRAIGHT)
13319 {
13320 log_info ("Rules: %u", kernel_rules_cnt);
13321 }
13322
13323 if (opti_type)
13324 {
13325 log_info ("Applicable Optimizers:");
13326
13327 for (uint i = 0; i < 32; i++)
13328 {
13329 const uint opti_bit = 1u << i;
13330
13331 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13332 }
13333 }
13334
13335 /**
13336 * Watchdog and Temperature balance
13337 */
13338
13339 #ifdef HAVE_HWMON
13340 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13341 {
13342 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13343 }
13344
13345 if (gpu_temp_abort == 0)
13346 {
13347 log_info ("Watchdog: Temperature abort trigger disabled");
13348 }
13349 else
13350 {
13351 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13352 }
13353
13354 if (gpu_temp_retain == 0)
13355 {
13356 log_info ("Watchdog: Temperature retain trigger disabled");
13357 }
13358 else
13359 {
13360 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13361 }
13362 #endif
13363 }
13364
13365 if (data.quiet == 0) log_info ("");
13366
13367 /**
13368 * HM devices: copy
13369 */
13370
13371 if (gpu_temp_disable == 0)
13372 {
13373 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13374 {
13375 hc_device_param_t *device_param = &data.devices_param[device_id];
13376
13377 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13378
13379 if (device_param->skipped) continue;
13380
13381 const uint platform_devices_id = device_param->platform_devices_id;
13382
13383 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13384 if (device_param->vendor_id == VENDOR_ID_NV)
13385 {
13386 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13387 }
13388 #endif
13389
13390 #ifdef HAVE_ADL
13391 if (device_param->vendor_id == VENDOR_ID_AMD)
13392 {
13393 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13394 }
13395 #endif
13396 }
13397 }
13398
13399 /*
13400 * Temporary fix:
13401 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13402 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13403 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13404 * Driver / ADL bug?
13405 */
13406
13407 #ifdef HAVE_ADL
13408 if (powertune_enable == 1)
13409 {
13410 hc_thread_mutex_lock (mux_adl);
13411
13412 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13413 {
13414 hc_device_param_t *device_param = &data.devices_param[device_id];
13415
13416 if (device_param->skipped) continue;
13417
13418 if (data.hm_device[device_id].od_version == 6)
13419 {
13420 // set powertune value only
13421
13422 int powertune_supported = 0;
13423
13424 int ADL_rc = 0;
13425
13426 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13427 {
13428 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13429
13430 return (-1);
13431 }
13432
13433 if (powertune_supported != 0)
13434 {
13435 // powertune set
13436 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13437
13438 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13439 {
13440 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13441
13442 return (-1);
13443 }
13444
13445 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13446 {
13447 log_error ("ERROR: Failed to set new ADL PowerControl values");
13448
13449 return (-1);
13450 }
13451 }
13452 }
13453 }
13454
13455 hc_thread_mutex_unlock (mux_adl);
13456 }
13457 #endif // HAVE_ADK
13458 #endif // HAVE_HWMON
13459
13460 #ifdef DEBUG
13461 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
13462 #endif
13463
13464 uint kernel_power_all = 0;
13465
13466 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13467 {
13468 /**
13469 * host buffer
13470 */
13471
13472 hc_device_param_t *device_param = &data.devices_param[device_id];
13473
13474 if (device_param->skipped) continue;
13475
13476 /**
13477 * device properties
13478 */
13479
13480 const char *device_name_chksum = device_param->device_name_chksum;
13481 const u32 device_processors = device_param->device_processors;
13482 const u32 device_processor_cores = device_param->device_processor_cores;
13483
13484 /**
13485 * create context for each device
13486 */
13487
13488 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
13489
13490 /**
13491 * create command-queue
13492 */
13493
13494 // not supported with NV
13495 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13496
13497 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
13498
13499 /**
13500 * create input buffers on device : calculate size of fixed memory buffers
13501 */
13502
13503 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13504 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13505
13506 device_param->size_root_css = size_root_css;
13507 device_param->size_markov_css = size_markov_css;
13508
13509 uint size_results = KERNEL_THREADS * sizeof (uint);
13510
13511 device_param->size_results = size_results;
13512
13513 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13514 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13515
13516 uint size_plains = digests_cnt * sizeof (plain_t);
13517 uint size_salts = salts_cnt * sizeof (salt_t);
13518 uint size_esalts = salts_cnt * esalt_size;
13519
13520 device_param->size_plains = size_plains;
13521 device_param->size_digests = size_digests;
13522 device_param->size_shown = size_shown;
13523 device_param->size_salts = size_salts;
13524
13525 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13526 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13527 uint size_tm = 32 * sizeof (bs_word_t);
13528
13529 // scryptV stuff
13530
13531 u64 size_scryptV = 1;
13532
13533 if ((hash_mode == 8900) || (hash_mode == 9300))
13534 {
13535 uint tmto_start = 0;
13536 uint tmto_stop = 10;
13537
13538 if (scrypt_tmto)
13539 {
13540 tmto_start = scrypt_tmto;
13541 }
13542 else
13543 {
13544 // in case the user did not specify the tmto manually
13545 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13546 // but set the lower end only in case the user has a device with too less memory
13547
13548 if (hash_mode == 8900)
13549 {
13550 if (device_param->vendor_id == VENDOR_ID_AMD)
13551 {
13552 tmto_start = 1;
13553 }
13554 else if (device_param->vendor_id == VENDOR_ID_NV)
13555 {
13556 tmto_start = 3;
13557 }
13558 }
13559 else if (hash_mode == 9300)
13560 {
13561 if (device_param->vendor_id == VENDOR_ID_AMD)
13562 {
13563 tmto_start = 3;
13564 }
13565 else if (device_param->vendor_id == VENDOR_ID_NV)
13566 {
13567 tmto_start = 5;
13568 }
13569 }
13570 }
13571
13572 if (quiet == 0) log_info ("");
13573
13574 uint shader_per_mp = 1;
13575
13576 if (device_param->vendor_id == VENDOR_ID_AMD)
13577 {
13578 shader_per_mp = 8;
13579 }
13580 else if (device_param->vendor_id == VENDOR_ID_NV)
13581 {
13582 shader_per_mp = 32;
13583 }
13584
13585 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13586 {
13587 // TODO: in theory the following calculation needs to be done per salt, not global
13588 // we assume all hashes have the same scrypt settings
13589
13590 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13591
13592 size_scryptV /= 1 << tmto;
13593
13594 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13595
13596 if (size_scryptV > device_param->device_maxmem_alloc)
13597 {
13598 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13599
13600 continue;
13601 }
13602
13603 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13604 {
13605 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13606 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13607 }
13608
13609 break;
13610 }
13611
13612 if (data.salts_buf[0].scrypt_phy == 0)
13613 {
13614 log_error ("ERROR: can't allocate enough device memory");
13615
13616 return -1;
13617 }
13618
13619 if (quiet == 0) log_info ("");
13620 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13621 }
13622
13623 /**
13624 * create input buffers on device : calculate size of dynamic size memory buffers
13625 */
13626
13627 uint kernel_threads = KERNEL_THREADS;
13628
13629 // some algorithms need a fixed kernel-threads count (mostly because of shared memory usage)
13630
13631 if (hash_mode == 3200) kernel_threads = 8;
13632 if (hash_mode == 9000) kernel_threads = 8;
13633
13634 /**
13635 * some algorithms need a fixed kernel-loops count
13636 */
13637
13638 if (hash_mode == 1500)
13639 {
13640 const u32 kernel_loops_fixed = 1024;
13641
13642 device_param->kernel_loops_min = kernel_loops_fixed;
13643 device_param->kernel_loops_max = kernel_loops_fixed;
13644 }
13645
13646 if (hash_mode == 3000)
13647 {
13648 const u32 kernel_loops_fixed = 1024;
13649
13650 device_param->kernel_loops_min = kernel_loops_fixed;
13651 device_param->kernel_loops_max = kernel_loops_fixed;
13652 }
13653
13654 if (hash_mode == 8900)
13655 {
13656 const u32 kernel_loops_fixed = 1;
13657
13658 device_param->kernel_loops_min = kernel_loops_fixed;
13659 device_param->kernel_loops_max = kernel_loops_fixed;
13660 }
13661
13662 if (hash_mode == 9300)
13663 {
13664 const u32 kernel_loops_fixed = 1;
13665
13666 device_param->kernel_loops_min = kernel_loops_fixed;
13667 device_param->kernel_loops_max = kernel_loops_fixed;
13668 }
13669
13670 if (hash_mode == 12500)
13671 {
13672 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
13673
13674 device_param->kernel_loops_min = kernel_loops_fixed;
13675 device_param->kernel_loops_max = kernel_loops_fixed;
13676 }
13677
13678 /**
13679 * some algorithms have a maximum kernel-loops count
13680 */
13681
13682 if (attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
13683 {
13684 if (data.salts_buf[0].salt_iter < device_param->kernel_loops_max)
13685 {
13686 device_param->kernel_loops_max = data.salts_buf[0].salt_iter;
13687 }
13688 }
13689
13690 /**
13691 * some algorithms need a special kernel-accel
13692 */
13693
13694 if (hash_mode == 8900)
13695 {
13696 device_param->kernel_accel_min = 1;
13697 device_param->kernel_accel_max = 64;
13698 }
13699
13700 if (hash_mode == 9300)
13701 {
13702 device_param->kernel_accel_min = 1;
13703 device_param->kernel_accel_max = 64;
13704 }
13705
13706 u32 kernel_accel_min = device_param->kernel_accel_min;
13707 u32 kernel_accel_max = device_param->kernel_accel_max;
13708
13709 // find out if we would request too much memory on memory blocks which are based on kernel_accel
13710
13711 uint size_pws = 4;
13712 uint size_tmps = 4;
13713 uint size_hooks = 4;
13714
13715 while (kernel_accel_max >= kernel_accel_min)
13716 {
13717 uint kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
13718
13719 // size_pws
13720
13721 size_pws = kernel_power_max * sizeof (pw_t);
13722
13723 // size_tmps
13724
13725 switch (hash_mode)
13726 {
13727 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
13728 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13729 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13730 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13731 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
13732 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
13733 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
13734 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
13735 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
13736 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
13737 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13738 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13739 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13740 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13741 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13742 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13743 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13744 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13745 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13746 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13747 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13748 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13749 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13750 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
13751 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
13752 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
13753 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
13754 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
13755 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13756 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13757 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
13758 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
13759 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13760 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
13761 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13762 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
13763 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
13764 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13765 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13766 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
13767 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
13768 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
13769 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13770 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
13771 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
13772 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
13773 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
13774 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13775 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
13776 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
13777 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
13778 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
13779 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13780 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
13781 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
13782 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
13783 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
13784 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
13785 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13786 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13787 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13788 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
13789 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
13790 };
13791
13792 // size_hooks
13793
13794 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13795 {
13796 // none yet
13797 }
13798
13799 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
13800 // if not, decrease amplifier and try again
13801
13802 int skip = 0;
13803
13804 if (size_pws > device_param->device_maxmem_alloc) skip = 1;
13805 if (size_tmps > device_param->device_maxmem_alloc) skip = 1;
13806 if (size_hooks > device_param->device_maxmem_alloc) skip = 1;
13807
13808 if (( bitmap_size
13809 + bitmap_size
13810 + bitmap_size
13811 + bitmap_size
13812 + bitmap_size
13813 + bitmap_size
13814 + bitmap_size
13815 + bitmap_size
13816 + size_bfs
13817 + size_combs
13818 + size_digests
13819 + size_esalts
13820 + size_hooks
13821 + size_markov_css
13822 + size_plains
13823 + size_pws
13824 + size_results
13825 + size_root_css
13826 + size_rules
13827 + size_rules_c
13828 + size_salts
13829 + size_scryptV
13830 + size_shown
13831 + size_tm
13832 + size_tmps) > device_param->device_global_mem) skip = 1;
13833
13834 if (skip == 1)
13835 {
13836 kernel_accel_max--;
13837
13838 continue;
13839 }
13840
13841 break;
13842 }
13843
13844 /*
13845 if (kernel_accel_max == 0)
13846 {
13847 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
13848
13849 return -1;
13850 }
13851 */
13852
13853 device_param->kernel_accel_min = kernel_accel_min;
13854 device_param->kernel_accel_max = kernel_accel_max;
13855
13856 /*
13857 if (kernel_accel_max < kernel_accel)
13858 {
13859 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
13860
13861 device_param->kernel_accel = kernel_accel_max;
13862 }
13863 */
13864
13865 device_param->size_bfs = size_bfs;
13866 device_param->size_combs = size_combs;
13867 device_param->size_rules = size_rules;
13868 device_param->size_rules_c = size_rules_c;
13869 device_param->size_pws = size_pws;
13870 device_param->size_tmps = size_tmps;
13871 device_param->size_hooks = size_hooks;
13872
13873 // do not confuse kernel_accel_max with kernel_accel here
13874
13875 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
13876
13877 device_param->kernel_threads = kernel_threads;
13878 device_param->kernel_power_user = kernel_power;
13879
13880 kernel_power_all += kernel_power;
13881
13882 /**
13883 * default building options
13884 */
13885
13886 char build_opts[1024] = { 0 };
13887
13888 // we don't have sm_* on vendors not NV but it doesn't matter
13889
13890 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);
13891
13892 /**
13893 * main kernel
13894 */
13895
13896 {
13897 /**
13898 * kernel source filename
13899 */
13900
13901 char source_file[256] = { 0 };
13902
13903 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13904
13905 struct stat sst;
13906
13907 if (stat (source_file, &sst) == -1)
13908 {
13909 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13910
13911 return -1;
13912 }
13913
13914 /**
13915 * kernel cached filename
13916 */
13917
13918 char cached_file[256] = { 0 };
13919
13920 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
13921
13922 int cached = 1;
13923
13924 struct stat cst;
13925
13926 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
13927 {
13928 cached = 0;
13929 }
13930
13931 /**
13932 * kernel compile or load
13933 */
13934
13935 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13936
13937 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13938
13939 if (force_jit_compilation == -1)
13940 {
13941 if (cached == 0)
13942 {
13943 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13944
13945 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13946
13947 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13948
13949 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
13950
13951 #ifdef DEBUG
13952 size_t build_log_size = 0;
13953
13954 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
13955
13956 if (build_log_size > 1)
13957 {
13958 char *build_log = (char *) malloc (build_log_size + 1);
13959
13960 memset (build_log, 0, build_log_size + 1);
13961
13962 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
13963
13964 puts (build_log);
13965
13966 free (build_log);
13967 }
13968 #endif
13969
13970 if (rc != 0)
13971 {
13972 device_param->skipped = true;
13973 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13974 continue;
13975 }
13976
13977 size_t binary_size;
13978
13979 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13980
13981 u8 *binary = (u8 *) mymalloc (binary_size);
13982
13983 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13984
13985 writeProgramBin (cached_file, binary, binary_size);
13986
13987 local_free (binary);
13988 }
13989 else
13990 {
13991 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13992
13993 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13994
13995 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13996
13997 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
13998 }
13999 }
14000 else
14001 {
14002 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
14003
14004 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14005
14006 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14007
14008 char build_opts_update[1024] = { 0 };
14009
14010 if (force_jit_compilation == 1500)
14011 {
14012 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
14013 }
14014 else if (force_jit_compilation == 8900)
14015 {
14016 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);
14017 }
14018 else
14019 {
14020 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
14021 }
14022
14023 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
14024
14025 #ifdef DEBUG
14026 size_t build_log_size = 0;
14027
14028 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14029
14030 if (build_log_size > 1)
14031 {
14032 char *build_log = (char *) malloc (build_log_size + 1);
14033
14034 memset (build_log, 0, build_log_size + 1);
14035
14036 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14037
14038 puts (build_log);
14039
14040 free (build_log);
14041 }
14042 #endif
14043
14044 if (rc != 0)
14045 {
14046 device_param->skipped = true;
14047
14048 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14049 }
14050 }
14051
14052 local_free (kernel_lengths);
14053 local_free (kernel_sources[0]);
14054 local_free (kernel_sources);
14055 }
14056
14057 /**
14058 * word generator kernel
14059 */
14060
14061 if (attack_mode != ATTACK_MODE_STRAIGHT)
14062 {
14063 /**
14064 * kernel mp source filename
14065 */
14066
14067 char source_file[256] = { 0 };
14068
14069 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
14070
14071 struct stat sst;
14072
14073 if (stat (source_file, &sst) == -1)
14074 {
14075 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14076
14077 return -1;
14078 }
14079
14080 /**
14081 * kernel mp cached filename
14082 */
14083
14084 char cached_file[256] = { 0 };
14085
14086 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
14087
14088 int cached = 1;
14089
14090 struct stat cst;
14091
14092 if (stat (cached_file, &cst) == -1)
14093 {
14094 cached = 0;
14095 }
14096
14097 /**
14098 * kernel compile or load
14099 */
14100
14101 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14102
14103 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14104
14105 if (cached == 0)
14106 {
14107 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14108
14109 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14110
14111 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14112
14113 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
14114
14115 if (rc != 0)
14116 {
14117 device_param->skipped = true;
14118 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14119 continue;
14120 }
14121
14122 size_t binary_size;
14123
14124 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14125
14126 u8 *binary = (u8 *) mymalloc (binary_size);
14127
14128 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14129
14130 writeProgramBin (cached_file, binary, binary_size);
14131
14132 local_free (binary);
14133 }
14134 else
14135 {
14136 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14137
14138 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14139
14140 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14141
14142 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
14143 }
14144
14145 local_free (kernel_lengths);
14146 local_free (kernel_sources[0]);
14147 local_free (kernel_sources);
14148 }
14149
14150 /**
14151 * amplifier kernel
14152 */
14153
14154 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14155 {
14156
14157 }
14158 else
14159 {
14160 /**
14161 * kernel amp source filename
14162 */
14163
14164 char source_file[256] = { 0 };
14165
14166 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
14167
14168 struct stat sst;
14169
14170 if (stat (source_file, &sst) == -1)
14171 {
14172 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14173
14174 return -1;
14175 }
14176
14177 /**
14178 * kernel amp cached filename
14179 */
14180
14181 char cached_file[256] = { 0 };
14182
14183 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
14184
14185 int cached = 1;
14186
14187 struct stat cst;
14188
14189 if (stat (cached_file, &cst) == -1)
14190 {
14191 cached = 0;
14192 }
14193
14194 /**
14195 * kernel compile or load
14196 */
14197
14198 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14199
14200 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14201
14202 if (cached == 0)
14203 {
14204 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14205
14206 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14207
14208 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14209
14210 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
14211
14212 if (rc != 0)
14213 {
14214 device_param->skipped = true;
14215 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14216 continue;
14217 }
14218
14219 size_t binary_size;
14220
14221 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14222
14223 u8 *binary = (u8 *) mymalloc (binary_size);
14224
14225 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14226
14227 writeProgramBin (cached_file, binary, binary_size);
14228
14229 local_free (binary);
14230 }
14231 else
14232 {
14233 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14234
14235 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14236
14237 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14238
14239 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
14240 }
14241
14242 local_free (kernel_lengths);
14243 local_free (kernel_sources[0]);
14244 local_free (kernel_sources);
14245 }
14246
14247 // some algorithm collide too fast, make that impossible
14248
14249 if (benchmark == 1)
14250 {
14251 ((uint *) digests_buf)[0] = -1;
14252 ((uint *) digests_buf)[1] = -1;
14253 ((uint *) digests_buf)[2] = -1;
14254 ((uint *) digests_buf)[3] = -1;
14255 }
14256
14257 /**
14258 * global buffers
14259 */
14260
14261 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14262 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14263 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
14264 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
14265 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14266 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14267 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14268 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14269 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14270 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14271 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14272 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14273 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
14274 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
14275 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
14276 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
14277 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
14278 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
14279
14280 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);
14281 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);
14282 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);
14283 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);
14284 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);
14285 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);
14286 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);
14287 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);
14288 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
14289 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
14290 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
14291
14292 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
14293 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
14294 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
14295 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
14296 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
14297 run_kernel_bzero (device_param, device_param->d_result, size_results);
14298
14299 /**
14300 * special buffers
14301 */
14302
14303 if (attack_kern == ATTACK_KERN_STRAIGHT)
14304 {
14305 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
14306 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
14307
14308 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
14309
14310 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
14311 }
14312 else if (attack_kern == ATTACK_KERN_COMBI)
14313 {
14314 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14315 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14316 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14317 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14318
14319 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
14320 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
14321 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14322 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14323 }
14324 else if (attack_kern == ATTACK_KERN_BF)
14325 {
14326 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14327 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14328 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
14329 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14330 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14331
14332 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
14333 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
14334 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
14335 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14336 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14337 }
14338
14339 if (size_esalts)
14340 {
14341 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
14342
14343 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
14344 }
14345
14346 /**
14347 * main host data
14348 */
14349
14350 uint *result = (uint *) mymalloc (size_results);
14351
14352 device_param->result = result;
14353
14354 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
14355
14356 device_param->pws_buf = pws_buf;
14357
14358 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
14359
14360 device_param->combs_buf = combs_buf;
14361
14362 void *hooks_buf = mymalloc (size_hooks);
14363
14364 device_param->hooks_buf = hooks_buf;
14365
14366 /**
14367 * kernel args
14368 */
14369
14370 device_param->kernel_params_buf32[21] = bitmap_mask;
14371 device_param->kernel_params_buf32[22] = bitmap_shift1;
14372 device_param->kernel_params_buf32[23] = bitmap_shift2;
14373 device_param->kernel_params_buf32[24] = 0; // salt_pos
14374 device_param->kernel_params_buf32[25] = 0; // loop_pos
14375 device_param->kernel_params_buf32[26] = 0; // loop_cnt
14376 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
14377 device_param->kernel_params_buf32[28] = 0; // digests_cnt
14378 device_param->kernel_params_buf32[29] = 0; // digests_offset
14379 device_param->kernel_params_buf32[30] = 0; // combs_mode
14380 device_param->kernel_params_buf32[31] = 0; // gid_max
14381
14382 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14383 ? &device_param->d_pws_buf
14384 : &device_param->d_pws_amp_buf;
14385 device_param->kernel_params[ 1] = &device_param->d_rules_c;
14386 device_param->kernel_params[ 2] = &device_param->d_combs_c;
14387 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
14388 device_param->kernel_params[ 4] = &device_param->d_tmps;
14389 device_param->kernel_params[ 5] = &device_param->d_hooks;
14390 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
14391 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
14392 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
14393 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
14394 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
14395 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
14396 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
14397 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
14398 device_param->kernel_params[14] = &device_param->d_plain_bufs;
14399 device_param->kernel_params[15] = &device_param->d_digests_buf;
14400 device_param->kernel_params[16] = &device_param->d_digests_shown;
14401 device_param->kernel_params[17] = &device_param->d_salt_bufs;
14402 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
14403 device_param->kernel_params[19] = &device_param->d_result;
14404 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
14405 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
14406 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
14407 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
14408 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
14409 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
14410 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
14411 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
14412 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
14413 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
14414 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
14415 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
14416
14417 device_param->kernel_params_mp_buf64[3] = 0;
14418 device_param->kernel_params_mp_buf32[4] = 0;
14419 device_param->kernel_params_mp_buf32[5] = 0;
14420 device_param->kernel_params_mp_buf32[6] = 0;
14421 device_param->kernel_params_mp_buf32[7] = 0;
14422 device_param->kernel_params_mp_buf32[8] = 0;
14423
14424 device_param->kernel_params_mp[0] = NULL;
14425 device_param->kernel_params_mp[1] = NULL;
14426 device_param->kernel_params_mp[2] = NULL;
14427 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
14428 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
14429 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
14430 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
14431 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
14432 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
14433
14434 device_param->kernel_params_mp_l_buf64[3] = 0;
14435 device_param->kernel_params_mp_l_buf32[4] = 0;
14436 device_param->kernel_params_mp_l_buf32[5] = 0;
14437 device_param->kernel_params_mp_l_buf32[6] = 0;
14438 device_param->kernel_params_mp_l_buf32[7] = 0;
14439 device_param->kernel_params_mp_l_buf32[8] = 0;
14440 device_param->kernel_params_mp_l_buf32[9] = 0;
14441
14442 device_param->kernel_params_mp_l[0] = NULL;
14443 device_param->kernel_params_mp_l[1] = NULL;
14444 device_param->kernel_params_mp_l[2] = NULL;
14445 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14446 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14447 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14448 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14449 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14450 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14451 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14452
14453 device_param->kernel_params_mp_r_buf64[3] = 0;
14454 device_param->kernel_params_mp_r_buf32[4] = 0;
14455 device_param->kernel_params_mp_r_buf32[5] = 0;
14456 device_param->kernel_params_mp_r_buf32[6] = 0;
14457 device_param->kernel_params_mp_r_buf32[7] = 0;
14458 device_param->kernel_params_mp_r_buf32[8] = 0;
14459
14460 device_param->kernel_params_mp_r[0] = NULL;
14461 device_param->kernel_params_mp_r[1] = NULL;
14462 device_param->kernel_params_mp_r[2] = NULL;
14463 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14464 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14465 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14466 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14467 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14468 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14469
14470 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14471 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14472
14473 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14474 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14475 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14476 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14477 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14478 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14479 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14480
14481 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14482 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14483
14484 /**
14485 * kernel name
14486 */
14487
14488 char kernel_name[64] = { 0 };
14489
14490 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14491 {
14492 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14493 {
14494 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14495
14496 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14497
14498 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14499
14500 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14501
14502 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14503
14504 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14505 }
14506 else
14507 {
14508 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14509
14510 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14511
14512 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14513
14514 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14515
14516 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14517
14518 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14519 }
14520
14521 if (data.attack_mode == ATTACK_MODE_BF)
14522 {
14523 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14524 {
14525 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14526
14527 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14528 }
14529 }
14530 }
14531 else
14532 {
14533 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14534
14535 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14536
14537 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14538
14539 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14540
14541 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14542
14543 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14544
14545 if (opts_type & OPTS_TYPE_HOOK12)
14546 {
14547 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14548
14549 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14550 }
14551
14552 if (opts_type & OPTS_TYPE_HOOK23)
14553 {
14554 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14555
14556 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14557 }
14558 }
14559
14560 for (uint i = 0; i <= 20; i++)
14561 {
14562 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14563 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14564 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14565
14566 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14567 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14568 }
14569
14570 for (uint i = 21; i <= 31; i++)
14571 {
14572 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14573 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14574 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14575
14576 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14577 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14578 }
14579
14580 if (attack_mode == ATTACK_MODE_BF)
14581 {
14582 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
14583 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
14584
14585 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14586 {
14587 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14588 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14589 }
14590 }
14591 else if (attack_mode == ATTACK_MODE_HYBRID1)
14592 {
14593 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14594 }
14595 else if (attack_mode == ATTACK_MODE_HYBRID2)
14596 {
14597 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14598 }
14599
14600 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14601 {
14602 // nothing to do
14603 }
14604 else
14605 {
14606 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
14607 }
14608
14609 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14610 {
14611 // nothing to do
14612 }
14613 else
14614 {
14615 for (uint i = 0; i < 5; i++)
14616 {
14617 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14618 }
14619
14620 for (uint i = 5; i < 7; i++)
14621 {
14622 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14623 }
14624 }
14625
14626 /**
14627 * Store initial fanspeed if gpu_temp_retain is enabled
14628 */
14629
14630 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
14631 int gpu_temp_retain_set = 0;
14632
14633 if (gpu_temp_disable == 0)
14634 {
14635 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14636 {
14637 hc_thread_mutex_lock (mux_adl);
14638
14639 if (data.hm_device[device_id].fan_supported == 1)
14640 {
14641 if (gpu_temp_retain_chgd == 0)
14642 {
14643 uint cur_temp = 0;
14644 uint default_temp = 0;
14645
14646 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);
14647
14648 if (ADL_rc == ADL_OK)
14649 {
14650 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14651
14652 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14653
14654 // special case with multi gpu setups: always use minimum retain
14655
14656 if (gpu_temp_retain_set == 0)
14657 {
14658 gpu_temp_retain = gpu_temp_retain_target;
14659 gpu_temp_retain_set = 1;
14660 }
14661 else
14662 {
14663 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14664 }
14665
14666 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14667 }
14668 }
14669
14670 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14671
14672 temp_retain_fanspeed_value[device_id] = fan_speed;
14673
14674 if (fan_speed == -1)
14675 {
14676 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14677
14678 temp_retain_fanspeed_value[device_id] = 0;
14679 }
14680 }
14681
14682 hc_thread_mutex_unlock (mux_adl);
14683 }
14684 }
14685
14686 /**
14687 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14688 */
14689
14690 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14691 {
14692 hc_thread_mutex_lock (mux_adl);
14693
14694 if (data.hm_device[device_id].od_version == 6)
14695 {
14696 int ADL_rc;
14697
14698 // check powertune capabilities first, if not available then skip device
14699
14700 int powertune_supported = 0;
14701
14702 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14703 {
14704 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14705
14706 return (-1);
14707 }
14708
14709 if (powertune_supported != 0)
14710 {
14711 // powercontrol settings
14712
14713 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14714
14715 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14716 {
14717 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14718 }
14719
14720 if (ADL_rc != ADL_OK)
14721 {
14722 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14723
14724 return (-1);
14725 }
14726
14727 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14728 {
14729 log_error ("ERROR: Failed to set new ADL PowerControl values");
14730
14731 return (-1);
14732 }
14733
14734 // clocks
14735
14736 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14737
14738 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14739
14740 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)
14741 {
14742 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14743
14744 return (-1);
14745 }
14746
14747 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14748
14749 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14750
14751 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14752 {
14753 log_error ("ERROR: Failed to get ADL device capabilities");
14754
14755 return (-1);
14756 }
14757
14758 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14759 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14760
14761 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14762 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14763
14764 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14765 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14766
14767 // warning if profile has too low max values
14768
14769 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14770 {
14771 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14772 }
14773
14774 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14775 {
14776 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14777 }
14778
14779 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14780
14781 performance_state->iNumberOfPerformanceLevels = 2;
14782
14783 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14784 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14785 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14786 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14787
14788 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)
14789 {
14790 log_info ("ERROR: Failed to set ADL performance state");
14791
14792 return (-1);
14793 }
14794
14795 local_free (performance_state);
14796 }
14797 }
14798
14799 hc_thread_mutex_unlock (mux_adl);
14800 }
14801 #endif // HAVE_HWMON && HAVE_ADL
14802 }
14803
14804 data.kernel_power_all = kernel_power_all;
14805
14806 if (data.quiet == 0) log_info ("");
14807
14808 /**
14809 * Inform user which algorithm is checked and at which workload setting
14810 */
14811
14812 if (benchmark == 1)
14813 {
14814 quiet = 0;
14815
14816 data.quiet = quiet;
14817
14818 char *hash_type = strhashtype (data.hash_mode); // not a bug
14819
14820 log_info ("Hashtype: %s", hash_type);
14821 log_info ("");
14822 }
14823
14824 /**
14825 * keep track of the progress
14826 */
14827
14828 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14829 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14830 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14831
14832 /**
14833 * open filehandles
14834 */
14835
14836 #if _WIN
14837 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14838 {
14839 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14840
14841 return (-1);
14842 }
14843
14844 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14845 {
14846 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14847
14848 return (-1);
14849 }
14850
14851 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14852 {
14853 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14854
14855 return (-1);
14856 }
14857 #endif
14858
14859 /**
14860 * dictionary pad
14861 */
14862
14863 segment_size *= (1024 * 1024);
14864
14865 data.segment_size = segment_size;
14866
14867 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14868
14869 wl_data->buf = (char *) mymalloc (segment_size);
14870 wl_data->avail = segment_size;
14871 wl_data->incr = segment_size;
14872 wl_data->cnt = 0;
14873 wl_data->pos = 0;
14874
14875 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14876
14877 data.wordlist_mode = wordlist_mode;
14878
14879 cs_t *css_buf = NULL;
14880 uint css_cnt = 0;
14881 uint dictcnt = 0;
14882 uint maskcnt = 1;
14883 char **masks = NULL;
14884 char **dictfiles = NULL;
14885
14886 uint mask_from_file = 0;
14887
14888 if (attack_mode == ATTACK_MODE_STRAIGHT)
14889 {
14890 if (wordlist_mode == WL_MODE_FILE)
14891 {
14892 int wls_left = myargc - (optind + 1);
14893
14894 for (int i = 0; i < wls_left; i++)
14895 {
14896 char *l0_filename = myargv[optind + 1 + i];
14897
14898 struct stat l0_stat;
14899
14900 if (stat (l0_filename, &l0_stat) == -1)
14901 {
14902 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14903
14904 return (-1);
14905 }
14906
14907 uint is_dir = S_ISDIR (l0_stat.st_mode);
14908
14909 if (is_dir == 0)
14910 {
14911 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14912
14913 dictcnt++;
14914
14915 dictfiles[dictcnt - 1] = l0_filename;
14916 }
14917 else
14918 {
14919 // do not allow --keyspace w/ a directory
14920
14921 if (keyspace == 1)
14922 {
14923 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14924
14925 return (-1);
14926 }
14927
14928 char **dictionary_files = NULL;
14929
14930 dictionary_files = scan_directory (l0_filename);
14931
14932 if (dictionary_files != NULL)
14933 {
14934 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14935
14936 for (int d = 0; dictionary_files[d] != NULL; d++)
14937 {
14938 char *l1_filename = dictionary_files[d];
14939
14940 struct stat l1_stat;
14941
14942 if (stat (l1_filename, &l1_stat) == -1)
14943 {
14944 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14945
14946 return (-1);
14947 }
14948
14949 if (S_ISREG (l1_stat.st_mode))
14950 {
14951 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14952
14953 dictcnt++;
14954
14955 dictfiles[dictcnt - 1] = strdup (l1_filename);
14956 }
14957 }
14958 }
14959
14960 local_free (dictionary_files);
14961 }
14962 }
14963
14964 if (dictcnt < 1)
14965 {
14966 log_error ("ERROR: No usable dictionary file found.");
14967
14968 return (-1);
14969 }
14970 }
14971 else if (wordlist_mode == WL_MODE_STDIN)
14972 {
14973 dictcnt = 1;
14974 }
14975 }
14976 else if (attack_mode == ATTACK_MODE_COMBI)
14977 {
14978 // display
14979
14980 char *dictfile1 = myargv[optind + 1 + 0];
14981 char *dictfile2 = myargv[optind + 1 + 1];
14982
14983 // find the bigger dictionary and use as base
14984
14985 FILE *fp1 = NULL;
14986 FILE *fp2 = NULL;
14987
14988 struct stat tmp_stat;
14989
14990 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14991 {
14992 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14993
14994 return (-1);
14995 }
14996
14997 if (stat (dictfile1, &tmp_stat) == -1)
14998 {
14999 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15000
15001 fclose (fp1);
15002
15003 return (-1);
15004 }
15005
15006 if (S_ISDIR (tmp_stat.st_mode))
15007 {
15008 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
15009
15010 fclose (fp1);
15011
15012 return (-1);
15013 }
15014
15015 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
15016 {
15017 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15018
15019 fclose (fp1);
15020
15021 return (-1);
15022 }
15023
15024 if (stat (dictfile2, &tmp_stat) == -1)
15025 {
15026 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15027
15028 fclose (fp1);
15029 fclose (fp2);
15030
15031 return (-1);
15032 }
15033
15034 if (S_ISDIR (tmp_stat.st_mode))
15035 {
15036 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
15037
15038 fclose (fp1);
15039 fclose (fp2);
15040
15041 return (-1);
15042 }
15043
15044 data.combs_cnt = 1;
15045
15046 data.quiet = 1;
15047
15048 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
15049
15050 data.quiet = quiet;
15051
15052 if (words1_cnt == 0)
15053 {
15054 log_error ("ERROR: %s: empty file", dictfile1);
15055
15056 fclose (fp1);
15057 fclose (fp2);
15058
15059 return (-1);
15060 }
15061
15062 data.combs_cnt = 1;
15063
15064 data.quiet = 1;
15065
15066 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
15067
15068 data.quiet = quiet;
15069
15070 if (words2_cnt == 0)
15071 {
15072 log_error ("ERROR: %s: empty file", dictfile2);
15073
15074 fclose (fp1);
15075 fclose (fp2);
15076
15077 return (-1);
15078 }
15079
15080 fclose (fp1);
15081 fclose (fp2);
15082
15083 data.dictfile = dictfile1;
15084 data.dictfile2 = dictfile2;
15085
15086 if (words1_cnt >= words2_cnt)
15087 {
15088 data.combs_cnt = words2_cnt;
15089 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15090
15091 dictfiles = &data.dictfile;
15092
15093 dictcnt = 1;
15094 }
15095 else
15096 {
15097 data.combs_cnt = words1_cnt;
15098 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15099
15100 dictfiles = &data.dictfile2;
15101
15102 dictcnt = 1;
15103
15104 // we also have to switch wordlist related rules!
15105
15106 char *tmpc = data.rule_buf_l;
15107
15108 data.rule_buf_l = data.rule_buf_r;
15109 data.rule_buf_r = tmpc;
15110
15111 int tmpi = data.rule_len_l;
15112
15113 data.rule_len_l = data.rule_len_r;
15114 data.rule_len_r = tmpi;
15115 }
15116 }
15117 else if (attack_mode == ATTACK_MODE_BF)
15118 {
15119 char *mask = NULL;
15120
15121 maskcnt = 0;
15122
15123 if (benchmark == 0)
15124 {
15125 mask = myargv[optind + 1];
15126
15127 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
15128
15129 if ((optind + 2) <= myargc)
15130 {
15131 struct stat file_stat;
15132
15133 if (stat (mask, &file_stat) == -1)
15134 {
15135 maskcnt = 1;
15136
15137 masks[maskcnt - 1] = mystrdup (mask);
15138 }
15139 else
15140 {
15141 int wls_left = myargc - (optind + 1);
15142
15143 uint masks_avail = INCR_MASKS;
15144
15145 for (int i = 0; i < wls_left; i++)
15146 {
15147 if (i != 0)
15148 {
15149 mask = myargv[optind + 1 + i];
15150
15151 if (stat (mask, &file_stat) == -1)
15152 {
15153 log_error ("ERROR: %s: %s", mask, strerror (errno));
15154
15155 return (-1);
15156 }
15157 }
15158
15159 uint is_file = S_ISREG (file_stat.st_mode);
15160
15161 if (is_file == 1)
15162 {
15163 FILE *mask_fp;
15164
15165 if ((mask_fp = fopen (mask, "r")) == NULL)
15166 {
15167 log_error ("ERROR: %s: %s", mask, strerror (errno));
15168
15169 return (-1);
15170 }
15171
15172 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15173
15174 while (!feof (mask_fp))
15175 {
15176 memset (line_buf, 0, HCBUFSIZ);
15177
15178 int line_len = fgetl (mask_fp, line_buf);
15179
15180 if (line_len == 0) continue;
15181
15182 if (line_buf[0] == '#') continue;
15183
15184 if (masks_avail == maskcnt)
15185 {
15186 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15187
15188 masks_avail += INCR_MASKS;
15189 }
15190
15191 masks[maskcnt] = mystrdup (line_buf);
15192
15193 maskcnt++;
15194 }
15195
15196 myfree (line_buf);
15197
15198 fclose (mask_fp);
15199 }
15200 else
15201 {
15202 log_error ("ERROR: %s: unsupported file-type", mask);
15203
15204 return (-1);
15205 }
15206 }
15207
15208 mask_from_file = 1;
15209 }
15210 }
15211 else
15212 {
15213 custom_charset_1 = (char *) "?l?d?u";
15214 custom_charset_2 = (char *) "?l?d";
15215 custom_charset_3 = (char *) "?l?d*!$@_";
15216
15217 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15218 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15219 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15220
15221 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
15222
15223 wordlist_mode = WL_MODE_MASK;
15224
15225 data.wordlist_mode = wordlist_mode;
15226
15227 increment = 1;
15228
15229 maskcnt = 1;
15230 }
15231 }
15232 else
15233 {
15234 /**
15235 * generate full masks and charsets
15236 */
15237
15238 masks = (char **) mymalloc (sizeof (char *));
15239
15240 switch (hash_mode)
15241 {
15242 case 1731: pw_min = 5;
15243 pw_max = 5;
15244 mask = mystrdup ("?b?b?b?b?b");
15245 break;
15246 case 12500: pw_min = 5;
15247 pw_max = 5;
15248 mask = mystrdup ("?b?b?b?b?b");
15249 break;
15250 default: pw_min = 7;
15251 pw_max = 7;
15252 mask = mystrdup ("?b?b?b?b?b?b?b");
15253 break;
15254 }
15255
15256 maskcnt = 1;
15257
15258 masks[maskcnt - 1] = mystrdup (mask);
15259
15260 wordlist_mode = WL_MODE_MASK;
15261
15262 data.wordlist_mode = wordlist_mode;
15263
15264 increment = 1;
15265 }
15266
15267 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
15268
15269 if (increment)
15270 {
15271 if (increment_min > pw_min) pw_min = increment_min;
15272
15273 if (increment_max < pw_max) pw_max = increment_max;
15274 }
15275 }
15276 else if (attack_mode == ATTACK_MODE_HYBRID1)
15277 {
15278 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15279
15280 // display
15281
15282 char *mask = myargv[myargc - 1];
15283
15284 maskcnt = 0;
15285
15286 masks = (char **) mymalloc (1 * sizeof (char *));
15287
15288 // mod
15289
15290 struct stat file_stat;
15291
15292 if (stat (mask, &file_stat) == -1)
15293 {
15294 maskcnt = 1;
15295
15296 masks[maskcnt - 1] = mystrdup (mask);
15297 }
15298 else
15299 {
15300 uint is_file = S_ISREG (file_stat.st_mode);
15301
15302 if (is_file == 1)
15303 {
15304 FILE *mask_fp;
15305
15306 if ((mask_fp = fopen (mask, "r")) == NULL)
15307 {
15308 log_error ("ERROR: %s: %s", mask, strerror (errno));
15309
15310 return (-1);
15311 }
15312
15313 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15314
15315 uint masks_avail = 1;
15316
15317 while (!feof (mask_fp))
15318 {
15319 memset (line_buf, 0, HCBUFSIZ);
15320
15321 int line_len = fgetl (mask_fp, line_buf);
15322
15323 if (line_len == 0) continue;
15324
15325 if (line_buf[0] == '#') continue;
15326
15327 if (masks_avail == maskcnt)
15328 {
15329 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15330
15331 masks_avail += INCR_MASKS;
15332 }
15333
15334 masks[maskcnt] = mystrdup (line_buf);
15335
15336 maskcnt++;
15337 }
15338
15339 myfree (line_buf);
15340
15341 fclose (mask_fp);
15342
15343 mask_from_file = 1;
15344 }
15345 else
15346 {
15347 maskcnt = 1;
15348
15349 masks[maskcnt - 1] = mystrdup (mask);
15350 }
15351 }
15352
15353 // base
15354
15355 int wls_left = myargc - (optind + 2);
15356
15357 for (int i = 0; i < wls_left; i++)
15358 {
15359 char *filename = myargv[optind + 1 + i];
15360
15361 struct stat file_stat;
15362
15363 if (stat (filename, &file_stat) == -1)
15364 {
15365 log_error ("ERROR: %s: %s", filename, strerror (errno));
15366
15367 return (-1);
15368 }
15369
15370 uint is_dir = S_ISDIR (file_stat.st_mode);
15371
15372 if (is_dir == 0)
15373 {
15374 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15375
15376 dictcnt++;
15377
15378 dictfiles[dictcnt - 1] = filename;
15379 }
15380 else
15381 {
15382 // do not allow --keyspace w/ a directory
15383
15384 if (keyspace == 1)
15385 {
15386 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15387
15388 return (-1);
15389 }
15390
15391 char **dictionary_files = NULL;
15392
15393 dictionary_files = scan_directory (filename);
15394
15395 if (dictionary_files != NULL)
15396 {
15397 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15398
15399 for (int d = 0; dictionary_files[d] != NULL; d++)
15400 {
15401 char *l1_filename = dictionary_files[d];
15402
15403 struct stat l1_stat;
15404
15405 if (stat (l1_filename, &l1_stat) == -1)
15406 {
15407 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15408
15409 return (-1);
15410 }
15411
15412 if (S_ISREG (l1_stat.st_mode))
15413 {
15414 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15415
15416 dictcnt++;
15417
15418 dictfiles[dictcnt - 1] = strdup (l1_filename);
15419 }
15420 }
15421 }
15422
15423 local_free (dictionary_files);
15424 }
15425 }
15426
15427 if (dictcnt < 1)
15428 {
15429 log_error ("ERROR: No usable dictionary file found.");
15430
15431 return (-1);
15432 }
15433
15434 if (increment)
15435 {
15436 maskcnt = 0;
15437
15438 uint mask_min = increment_min; // we can't reject smaller masks here
15439 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15440
15441 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15442 {
15443 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15444
15445 if (cur_mask == NULL) break;
15446
15447 masks[maskcnt] = cur_mask;
15448
15449 maskcnt++;
15450
15451 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15452 }
15453 }
15454 }
15455 else if (attack_mode == ATTACK_MODE_HYBRID2)
15456 {
15457 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15458
15459 // display
15460
15461 char *mask = myargv[optind + 1 + 0];
15462
15463 maskcnt = 0;
15464
15465 masks = (char **) mymalloc (1 * sizeof (char *));
15466
15467 // mod
15468
15469 struct stat file_stat;
15470
15471 if (stat (mask, &file_stat) == -1)
15472 {
15473 maskcnt = 1;
15474
15475 masks[maskcnt - 1] = mystrdup (mask);
15476 }
15477 else
15478 {
15479 uint is_file = S_ISREG (file_stat.st_mode);
15480
15481 if (is_file == 1)
15482 {
15483 FILE *mask_fp;
15484
15485 if ((mask_fp = fopen (mask, "r")) == NULL)
15486 {
15487 log_error ("ERROR: %s: %s", mask, strerror (errno));
15488
15489 return (-1);
15490 }
15491
15492 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15493
15494 uint masks_avail = 1;
15495
15496 while (!feof (mask_fp))
15497 {
15498 memset (line_buf, 0, HCBUFSIZ);
15499
15500 int line_len = fgetl (mask_fp, line_buf);
15501
15502 if (line_len == 0) continue;
15503
15504 if (line_buf[0] == '#') continue;
15505
15506 if (masks_avail == maskcnt)
15507 {
15508 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15509
15510 masks_avail += INCR_MASKS;
15511 }
15512
15513 masks[maskcnt] = mystrdup (line_buf);
15514
15515 maskcnt++;
15516 }
15517
15518 myfree (line_buf);
15519
15520 fclose (mask_fp);
15521
15522 mask_from_file = 1;
15523 }
15524 else
15525 {
15526 maskcnt = 1;
15527
15528 masks[maskcnt - 1] = mystrdup (mask);
15529 }
15530 }
15531
15532 // base
15533
15534 int wls_left = myargc - (optind + 2);
15535
15536 for (int i = 0; i < wls_left; i++)
15537 {
15538 char *filename = myargv[optind + 2 + i];
15539
15540 struct stat file_stat;
15541
15542 if (stat (filename, &file_stat) == -1)
15543 {
15544 log_error ("ERROR: %s: %s", filename, strerror (errno));
15545
15546 return (-1);
15547 }
15548
15549 uint is_dir = S_ISDIR (file_stat.st_mode);
15550
15551 if (is_dir == 0)
15552 {
15553 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15554
15555 dictcnt++;
15556
15557 dictfiles[dictcnt - 1] = filename;
15558 }
15559 else
15560 {
15561 // do not allow --keyspace w/ a directory
15562
15563 if (keyspace == 1)
15564 {
15565 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15566
15567 return (-1);
15568 }
15569
15570 char **dictionary_files = NULL;
15571
15572 dictionary_files = scan_directory (filename);
15573
15574 if (dictionary_files != NULL)
15575 {
15576 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15577
15578 for (int d = 0; dictionary_files[d] != NULL; d++)
15579 {
15580 char *l1_filename = dictionary_files[d];
15581
15582 struct stat l1_stat;
15583
15584 if (stat (l1_filename, &l1_stat) == -1)
15585 {
15586 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15587
15588 return (-1);
15589 }
15590
15591 if (S_ISREG (l1_stat.st_mode))
15592 {
15593 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15594
15595 dictcnt++;
15596
15597 dictfiles[dictcnt - 1] = strdup (l1_filename);
15598 }
15599 }
15600 }
15601
15602 local_free (dictionary_files);
15603 }
15604 }
15605
15606 if (dictcnt < 1)
15607 {
15608 log_error ("ERROR: No usable dictionary file found.");
15609
15610 return (-1);
15611 }
15612
15613 if (increment)
15614 {
15615 maskcnt = 0;
15616
15617 uint mask_min = increment_min; // we can't reject smaller masks here
15618 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15619
15620 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15621 {
15622 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15623
15624 if (cur_mask == NULL) break;
15625
15626 masks[maskcnt] = cur_mask;
15627
15628 maskcnt++;
15629
15630 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15631 }
15632 }
15633 }
15634
15635 data.pw_min = pw_min;
15636 data.pw_max = pw_max;
15637
15638 /**
15639 * weak hash check
15640 */
15641
15642 if (weak_hash_threshold >= salts_cnt)
15643 {
15644 hc_device_param_t *device_param = NULL;
15645
15646 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15647 {
15648 device_param = &data.devices_param[device_id];
15649
15650 if (device_param->skipped) continue;
15651
15652 break;
15653 }
15654
15655 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15656
15657 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15658 {
15659 weak_hash_check (device_param, salt_pos);
15660 }
15661 }
15662
15663 // Display hack, guarantee that there is at least one \r before real start
15664
15665 if (data.quiet == 0) log_info_nn ("");
15666
15667 /**
15668 * status and monitor threads
15669 */
15670
15671 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15672
15673 hc_thread_t i_thread = 0;
15674
15675 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15676 {
15677 hc_thread_create (i_thread, thread_keypress, &benchmark);
15678 }
15679
15680 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15681
15682 uint ni_threads_cnt = 0;
15683
15684 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15685
15686 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15687
15688 ni_threads_cnt++;
15689
15690 /**
15691 * Outfile remove
15692 */
15693
15694 if (keyspace == 0)
15695 {
15696 if (outfile_check_timer != 0)
15697 {
15698 if (data.outfile_check_directory != NULL)
15699 {
15700 if ((hash_mode != 5200) &&
15701 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15702 (hash_mode != 9000))
15703 {
15704 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15705
15706 ni_threads_cnt++;
15707 }
15708 else
15709 {
15710 outfile_check_timer = 0;
15711 }
15712 }
15713 else
15714 {
15715 outfile_check_timer = 0;
15716 }
15717 }
15718 }
15719
15720 /**
15721 * Inform the user if we got some hashes remove because of the pot file remove feature
15722 */
15723
15724 if (data.quiet == 0)
15725 {
15726 if (potfile_remove_cracks > 0)
15727 {
15728 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15729 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15730 }
15731 }
15732
15733 data.outfile_check_timer = outfile_check_timer;
15734
15735 /**
15736 * main loop
15737 */
15738
15739 char **induction_dictionaries = NULL;
15740
15741 int induction_dictionaries_cnt = 0;
15742
15743 hcstat_table_t *root_table_buf = NULL;
15744 hcstat_table_t *markov_table_buf = NULL;
15745
15746 uint initial_restore_done = 0;
15747
15748 data.maskcnt = maskcnt;
15749
15750 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15751 {
15752 if (data.devices_status == STATUS_CRACKED) break;
15753
15754 data.devices_status = STATUS_INIT;
15755
15756 if (maskpos > rd->maskpos)
15757 {
15758 rd->dictpos = 0;
15759 }
15760
15761 rd->maskpos = maskpos;
15762 data.maskpos = maskpos;
15763
15764 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15765 {
15766 char *mask = masks[maskpos];
15767
15768 if (mask_from_file == 1)
15769 {
15770 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15771
15772 char *str_ptr;
15773 uint str_pos;
15774
15775 uint mask_offset = 0;
15776
15777 uint separator_cnt;
15778
15779 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15780 {
15781 str_ptr = strstr (mask + mask_offset, ",");
15782
15783 if (str_ptr == NULL) break;
15784
15785 str_pos = str_ptr - mask;
15786
15787 // escaped separator, i.e. "\,"
15788
15789 if (str_pos > 0)
15790 {
15791 if (mask[str_pos - 1] == '\\')
15792 {
15793 separator_cnt --;
15794
15795 mask_offset = str_pos + 1;
15796
15797 continue;
15798 }
15799 }
15800
15801 // reset the offset
15802
15803 mask_offset = 0;
15804
15805 mask[str_pos] = '\0';
15806
15807 switch (separator_cnt)
15808 {
15809 case 0:
15810 mp_reset_usr (mp_usr, 0);
15811
15812 custom_charset_1 = mask;
15813 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15814 break;
15815
15816 case 1:
15817 mp_reset_usr (mp_usr, 1);
15818
15819 custom_charset_2 = mask;
15820 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15821 break;
15822
15823 case 2:
15824 mp_reset_usr (mp_usr, 2);
15825
15826 custom_charset_3 = mask;
15827 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15828 break;
15829
15830 case 3:
15831 mp_reset_usr (mp_usr, 3);
15832
15833 custom_charset_4 = mask;
15834 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15835 break;
15836 }
15837
15838 mask = mask + str_pos + 1;
15839 }
15840 }
15841
15842 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15843 {
15844 if (maskpos > 0)
15845 {
15846 local_free (css_buf);
15847 local_free (data.root_css_buf);
15848 local_free (data.markov_css_buf);
15849
15850 local_free (masks[maskpos - 1]);
15851 }
15852
15853 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15854
15855 data.mask = mask;
15856 data.css_cnt = css_cnt;
15857 data.css_buf = css_buf;
15858
15859 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15860
15861 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15862
15863 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15864 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15865
15866 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15867
15868 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15869
15870 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15871 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15872
15873 data.root_css_buf = root_css_buf;
15874 data.markov_css_buf = markov_css_buf;
15875
15876 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15877
15878 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15879
15880 local_free (root_table_buf);
15881 local_free (markov_table_buf);
15882
15883 // args
15884
15885 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15886 {
15887 hc_device_param_t *device_param = &data.devices_param[device_id];
15888
15889 if (device_param->skipped) continue;
15890
15891 device_param->kernel_params_mp[0] = &device_param->d_combs;
15892 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15893 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15894
15895 device_param->kernel_params_mp_buf64[3] = 0;
15896 device_param->kernel_params_mp_buf32[4] = css_cnt;
15897 device_param->kernel_params_mp_buf32[5] = 0;
15898 device_param->kernel_params_mp_buf32[6] = 0;
15899 device_param->kernel_params_mp_buf32[7] = 0;
15900
15901 if (attack_mode == ATTACK_MODE_HYBRID1)
15902 {
15903 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15904 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15905 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15906 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15907 }
15908 else if (attack_mode == ATTACK_MODE_HYBRID2)
15909 {
15910 device_param->kernel_params_mp_buf32[5] = 0;
15911 device_param->kernel_params_mp_buf32[6] = 0;
15912 device_param->kernel_params_mp_buf32[7] = 0;
15913 }
15914
15915 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]);
15916 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]);
15917 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]);
15918
15919 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);
15920 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);
15921 }
15922 }
15923 else if (attack_mode == ATTACK_MODE_BF)
15924 {
15925 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15926
15927 if (increment)
15928 {
15929 for (uint i = 0; i < dictcnt; i++)
15930 {
15931 local_free (dictfiles[i]);
15932 }
15933
15934 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15935 {
15936 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15937
15938 if (l1_filename == NULL) break;
15939
15940 dictcnt++;
15941
15942 dictfiles[dictcnt - 1] = l1_filename;
15943 }
15944 }
15945 else
15946 {
15947 dictcnt++;
15948
15949 dictfiles[dictcnt - 1] = mask;
15950 }
15951
15952 if (dictcnt == 0)
15953 {
15954 log_error ("ERROR: Mask is too small");
15955
15956 return (-1);
15957 }
15958 }
15959 }
15960
15961 free (induction_dictionaries);
15962
15963 // induction_dictionaries_cnt = 0; // implied
15964
15965 if (attack_mode != ATTACK_MODE_BF)
15966 {
15967 if (keyspace == 0)
15968 {
15969 induction_dictionaries = scan_directory (induction_directory);
15970
15971 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15972 }
15973 }
15974
15975 if (induction_dictionaries_cnt)
15976 {
15977 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15978 }
15979
15980 /**
15981 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15982 */
15983 if (keyspace == 1)
15984 {
15985 if ((maskcnt > 1) || (dictcnt > 1))
15986 {
15987 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15988
15989 return (-1);
15990 }
15991 }
15992
15993 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15994 {
15995 char *subid = logfile_generate_subid ();
15996
15997 data.subid = subid;
15998
15999 logfile_sub_msg ("START");
16000
16001 data.devices_status = STATUS_INIT;
16002
16003 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
16004 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
16005 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
16006
16007 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
16008
16009 data.cpt_pos = 0;
16010
16011 data.cpt_start = time (NULL);
16012
16013 data.cpt_total = 0;
16014
16015 if (data.restore == 0)
16016 {
16017 rd->words_cur = skip;
16018
16019 skip = 0;
16020
16021 data.skip = 0;
16022 }
16023
16024 data.ms_paused = 0;
16025
16026 data.words_cur = rd->words_cur;
16027
16028 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16029 {
16030 hc_device_param_t *device_param = &data.devices_param[device_id];
16031
16032 if (device_param->skipped) continue;
16033
16034 device_param->speed_pos = 0;
16035
16036 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
16037 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
16038 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
16039
16040 device_param->exec_pos = 0;
16041
16042 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
16043
16044 device_param->kernel_power = device_param->kernel_power_user;
16045
16046 device_param->outerloop_pos = 0;
16047 device_param->outerloop_left = 0;
16048 device_param->innerloop_pos = 0;
16049 device_param->innerloop_left = 0;
16050
16051 // some more resets:
16052
16053 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
16054
16055 device_param->pws_cnt = 0;
16056
16057 device_param->words_off = 0;
16058 device_param->words_done = 0;
16059 }
16060
16061 data.kernel_power_div = 0;
16062
16063 // figure out some workload
16064
16065 if (attack_mode == ATTACK_MODE_STRAIGHT)
16066 {
16067 if (data.wordlist_mode == WL_MODE_FILE)
16068 {
16069 char *dictfile = NULL;
16070
16071 if (induction_dictionaries_cnt)
16072 {
16073 dictfile = induction_dictionaries[0];
16074 }
16075 else
16076 {
16077 dictfile = dictfiles[dictpos];
16078 }
16079
16080 data.dictfile = dictfile;
16081
16082 logfile_sub_string (dictfile);
16083
16084 for (uint i = 0; i < rp_files_cnt; i++)
16085 {
16086 logfile_sub_var_string ("rulefile", rp_files[i]);
16087 }
16088
16089 FILE *fd2 = fopen (dictfile, "rb");
16090
16091 if (fd2 == NULL)
16092 {
16093 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16094
16095 return (-1);
16096 }
16097
16098 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16099
16100 fclose (fd2);
16101
16102 if (data.words_cnt == 0)
16103 {
16104 if (data.devices_status == STATUS_CRACKED) break;
16105 if (data.devices_status == STATUS_ABORTED) break;
16106
16107 dictpos++;
16108
16109 continue;
16110 }
16111 }
16112 }
16113 else if (attack_mode == ATTACK_MODE_COMBI)
16114 {
16115 char *dictfile = data.dictfile;
16116 char *dictfile2 = data.dictfile2;
16117
16118 logfile_sub_string (dictfile);
16119 logfile_sub_string (dictfile2);
16120
16121 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
16122 {
16123 FILE *fd2 = fopen (dictfile, "rb");
16124
16125 if (fd2 == NULL)
16126 {
16127 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16128
16129 return (-1);
16130 }
16131
16132 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16133
16134 fclose (fd2);
16135 }
16136 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
16137 {
16138 FILE *fd2 = fopen (dictfile2, "rb");
16139
16140 if (fd2 == NULL)
16141 {
16142 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16143
16144 return (-1);
16145 }
16146
16147 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
16148
16149 fclose (fd2);
16150 }
16151
16152 if (data.words_cnt == 0)
16153 {
16154 if (data.devices_status == STATUS_CRACKED) break;
16155 if (data.devices_status == STATUS_ABORTED) break;
16156
16157 dictpos++;
16158
16159 continue;
16160 }
16161 }
16162 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16163 {
16164 char *dictfile = NULL;
16165
16166 if (induction_dictionaries_cnt)
16167 {
16168 dictfile = induction_dictionaries[0];
16169 }
16170 else
16171 {
16172 dictfile = dictfiles[dictpos];
16173 }
16174
16175 data.dictfile = dictfile;
16176
16177 char *mask = data.mask;
16178
16179 logfile_sub_string (dictfile);
16180 logfile_sub_string (mask);
16181
16182 FILE *fd2 = fopen (dictfile, "rb");
16183
16184 if (fd2 == NULL)
16185 {
16186 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16187
16188 return (-1);
16189 }
16190
16191 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16192
16193 fclose (fd2);
16194
16195 if (data.words_cnt == 0)
16196 {
16197 if (data.devices_status == STATUS_CRACKED) break;
16198 if (data.devices_status == STATUS_ABORTED) break;
16199
16200 dictpos++;
16201
16202 continue;
16203 }
16204 }
16205 else if (attack_mode == ATTACK_MODE_BF)
16206 {
16207 local_free (css_buf);
16208 local_free (data.root_css_buf);
16209 local_free (data.markov_css_buf);
16210
16211 char *mask = dictfiles[dictpos];
16212
16213 logfile_sub_string (mask);
16214
16215 // base
16216
16217 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16218
16219 if (opts_type & OPTS_TYPE_PT_UNICODE)
16220 {
16221 uint css_cnt_unicode = css_cnt * 2;
16222
16223 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
16224
16225 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
16226 {
16227 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
16228
16229 css_buf_unicode[j + 1].cs_buf[0] = 0;
16230 css_buf_unicode[j + 1].cs_len = 1;
16231 }
16232
16233 free (css_buf);
16234
16235 css_buf = css_buf_unicode;
16236 css_cnt = css_cnt_unicode;
16237 }
16238
16239 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
16240
16241 uint mask_min = pw_min;
16242 uint mask_max = pw_max;
16243
16244 if (opts_type & OPTS_TYPE_PT_UNICODE)
16245 {
16246 mask_min *= 2;
16247 mask_max *= 2;
16248 }
16249
16250 if ((css_cnt < mask_min) || (css_cnt > mask_max))
16251 {
16252 if (css_cnt < mask_min)
16253 {
16254 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
16255 }
16256
16257 if (css_cnt > mask_max)
16258 {
16259 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
16260 }
16261
16262 // skip to next mask
16263
16264 dictpos++;
16265
16266 rd->dictpos = dictpos;
16267
16268 logfile_sub_msg ("STOP");
16269
16270 continue;
16271 }
16272
16273 uint save_css_cnt = css_cnt;
16274
16275 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16276 {
16277 if (opti_type & OPTI_TYPE_APPENDED_SALT)
16278 {
16279 uint salt_len = (uint) data.salts_buf[0].salt_len;
16280 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
16281
16282 uint css_cnt_salt = css_cnt + salt_len;
16283
16284 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
16285
16286 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
16287
16288 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
16289 {
16290 css_buf_salt[j].cs_buf[0] = salt_buf[i];
16291 css_buf_salt[j].cs_len = 1;
16292 }
16293
16294 free (css_buf);
16295
16296 css_buf = css_buf_salt;
16297 css_cnt = css_cnt_salt;
16298 }
16299 }
16300
16301 data.mask = mask;
16302 data.css_cnt = css_cnt;
16303 data.css_buf = css_buf;
16304
16305 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
16306
16307 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16308
16309 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16310
16311 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16312 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16313
16314 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16315
16316 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16317
16318 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16319 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16320
16321 data.root_css_buf = root_css_buf;
16322 data.markov_css_buf = markov_css_buf;
16323
16324 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16325
16326 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16327
16328 local_free (root_table_buf);
16329 local_free (markov_table_buf);
16330
16331 // copy + args
16332
16333 uint css_cnt_l = css_cnt;
16334 uint css_cnt_r;
16335
16336 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16337 {
16338 if (save_css_cnt < 6)
16339 {
16340 css_cnt_r = 1;
16341 }
16342 else if (save_css_cnt == 6)
16343 {
16344 css_cnt_r = 2;
16345 }
16346 else
16347 {
16348 if (opts_type & OPTS_TYPE_PT_UNICODE)
16349 {
16350 if (save_css_cnt == 8 || save_css_cnt == 10)
16351 {
16352 css_cnt_r = 2;
16353 }
16354 else
16355 {
16356 css_cnt_r = 4;
16357 }
16358 }
16359 else
16360 {
16361 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
16362 {
16363 css_cnt_r = 3;
16364 }
16365 else
16366 {
16367 css_cnt_r = 4;
16368 }
16369 }
16370 }
16371 }
16372 else
16373 {
16374 css_cnt_r = 1;
16375
16376 /* unfinished code?
16377 int sum = css_buf[css_cnt_r - 1].cs_len;
16378
16379 for (uint i = 1; i < 4 && i < css_cnt; i++)
16380 {
16381 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
16382
16383 css_cnt_r++;
16384
16385 sum *= css_buf[css_cnt_r - 1].cs_len;
16386 }
16387 */
16388 }
16389
16390 css_cnt_l -= css_cnt_r;
16391
16392 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
16393
16394 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16395 {
16396 hc_device_param_t *device_param = &data.devices_param[device_id];
16397
16398 if (device_param->skipped) continue;
16399
16400 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
16401 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
16402 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
16403
16404 device_param->kernel_params_mp_l_buf64[3] = 0;
16405 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
16406 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
16407 device_param->kernel_params_mp_l_buf32[6] = 0;
16408 device_param->kernel_params_mp_l_buf32[7] = 0;
16409 device_param->kernel_params_mp_l_buf32[8] = 0;
16410
16411 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
16412 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
16413 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
16414 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
16415
16416 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
16417 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
16418 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
16419
16420 device_param->kernel_params_mp_r_buf64[3] = 0;
16421 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
16422 device_param->kernel_params_mp_r_buf32[5] = 0;
16423 device_param->kernel_params_mp_r_buf32[6] = 0;
16424 device_param->kernel_params_mp_r_buf32[7] = 0;
16425
16426 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]);
16427 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]);
16428 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]);
16429
16430 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]);
16431 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]);
16432 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]);
16433
16434 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);
16435 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);
16436 }
16437 }
16438
16439 u64 words_base = data.words_cnt;
16440
16441 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16442 {
16443 if (data.kernel_rules_cnt)
16444 {
16445 words_base /= data.kernel_rules_cnt;
16446 }
16447 }
16448 else if (data.attack_kern == ATTACK_KERN_COMBI)
16449 {
16450 if (data.combs_cnt)
16451 {
16452 words_base /= data.combs_cnt;
16453 }
16454 }
16455 else if (data.attack_kern == ATTACK_KERN_BF)
16456 {
16457 if (data.bfs_cnt)
16458 {
16459 words_base /= data.bfs_cnt;
16460 }
16461 }
16462
16463 data.words_base = words_base;
16464
16465 if (keyspace == 1)
16466 {
16467 log_info ("%llu", (unsigned long long int) words_base);
16468
16469 return (0);
16470 }
16471
16472 if (data.words_cur > data.words_base)
16473 {
16474 log_error ("ERROR: restore value greater keyspace");
16475
16476 return (-1);
16477 }
16478
16479 if (data.words_cur)
16480 {
16481 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16482 {
16483 for (uint i = 0; i < data.salts_cnt; i++)
16484 {
16485 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16486 }
16487 }
16488 else if (data.attack_kern == ATTACK_KERN_COMBI)
16489 {
16490 for (uint i = 0; i < data.salts_cnt; i++)
16491 {
16492 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16493 }
16494 }
16495 else if (data.attack_kern == ATTACK_KERN_BF)
16496 {
16497 for (uint i = 0; i < data.salts_cnt; i++)
16498 {
16499 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16500 }
16501 }
16502 }
16503
16504 /*
16505 * Inform user about possible slow speeds
16506 */
16507
16508 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16509 {
16510 if (data.words_base < kernel_power_all)
16511 {
16512 if (quiet == 0)
16513 {
16514 log_info ("");
16515 log_info ("ATTENTION!");
16516 log_info (" The wordlist or mask you are using is too small.");
16517 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
16518 log_info (" The cracking speed will drop.");
16519 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16520 log_info ("");
16521 }
16522 }
16523 }
16524
16525 /*
16526 * Update loopback file
16527 */
16528
16529 if (loopback == 1)
16530 {
16531 time_t now;
16532
16533 time (&now);
16534
16535 uint random_num = get_random_num (0, 9999);
16536
16537 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16538
16539 data.loopback_file = loopback_file;
16540 }
16541
16542 /*
16543 * Update dictionary statistic
16544 */
16545
16546 if (keyspace == 0)
16547 {
16548 dictstat_fp = fopen (dictstat, "wb");
16549
16550 if (dictstat_fp)
16551 {
16552 lock_file (dictstat_fp);
16553
16554 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16555
16556 fclose (dictstat_fp);
16557 }
16558 }
16559
16560 data.devices_status = STATUS_RUNNING;
16561
16562 if (initial_restore_done == 0)
16563 {
16564 if (data.restore_disable == 0) cycle_restore ();
16565
16566 initial_restore_done = 1;
16567 }
16568
16569 hc_timer_set (&data.timer_running);
16570
16571 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16572 {
16573 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16574 {
16575 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16576 if (quiet == 0) fflush (stdout);
16577 }
16578 }
16579 else if (wordlist_mode == WL_MODE_STDIN)
16580 {
16581 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16582 if (data.quiet == 0) log_info ("");
16583 }
16584
16585 time_t runtime_start;
16586
16587 time (&runtime_start);
16588
16589 data.runtime_start = runtime_start;
16590
16591 /**
16592 * create cracker threads
16593 */
16594
16595 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
16596
16597 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16598 {
16599 hc_device_param_t *device_param = &devices_param[device_id];
16600
16601 if (wordlist_mode == WL_MODE_STDIN)
16602 {
16603 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16604 }
16605 else
16606 {
16607 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16608 }
16609 }
16610
16611 // wait for crack threads to exit
16612
16613 hc_thread_wait (data.devices_cnt, c_threads);
16614
16615 local_free (c_threads);
16616
16617 data.restore = 0;
16618
16619 // finalize task
16620
16621 logfile_sub_var_uint ("status-after-work", data.devices_status);
16622
16623 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16624
16625 if (data.devices_status == STATUS_CRACKED) break;
16626 if (data.devices_status == STATUS_ABORTED) break;
16627
16628 if (data.devices_status == STATUS_BYPASS)
16629 {
16630 data.devices_status = STATUS_RUNNING;
16631 }
16632
16633 if (induction_dictionaries_cnt)
16634 {
16635 unlink (induction_dictionaries[0]);
16636 }
16637
16638 free (induction_dictionaries);
16639
16640 if (attack_mode != ATTACK_MODE_BF)
16641 {
16642 induction_dictionaries = scan_directory (induction_directory);
16643
16644 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16645 }
16646
16647 if (benchmark == 0)
16648 {
16649 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16650 {
16651 if (quiet == 0) clear_prompt ();
16652
16653 if (quiet == 0) log_info ("");
16654
16655 if (status == 1)
16656 {
16657 status_display ();
16658 }
16659 else
16660 {
16661 if (quiet == 0) status_display ();
16662 }
16663
16664 if (quiet == 0) log_info ("");
16665 }
16666 }
16667
16668 if (attack_mode == ATTACK_MODE_BF)
16669 {
16670 dictpos++;
16671
16672 rd->dictpos = dictpos;
16673 }
16674 else
16675 {
16676 if (induction_dictionaries_cnt)
16677 {
16678 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16679 }
16680 else
16681 {
16682 dictpos++;
16683
16684 rd->dictpos = dictpos;
16685 }
16686 }
16687
16688 time_t runtime_stop;
16689
16690 time (&runtime_stop);
16691
16692 data.runtime_stop = runtime_stop;
16693
16694 logfile_sub_uint (runtime_start);
16695 logfile_sub_uint (runtime_stop);
16696
16697 logfile_sub_msg ("STOP");
16698
16699 global_free (subid);
16700 }
16701
16702 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16703
16704 if (data.devices_status == STATUS_CRACKED) break;
16705 if (data.devices_status == STATUS_ABORTED) break;
16706 if (data.devices_status == STATUS_QUIT) break;
16707
16708 if (data.devices_status == STATUS_BYPASS)
16709 {
16710 data.devices_status = STATUS_RUNNING;
16711 }
16712 }
16713
16714 // 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
16715
16716 if (attack_mode == ATTACK_MODE_STRAIGHT)
16717 {
16718 if (data.wordlist_mode == WL_MODE_FILE)
16719 {
16720 if (data.dictfile == NULL)
16721 {
16722 if (dictfiles != NULL)
16723 {
16724 data.dictfile = dictfiles[0];
16725
16726 hc_timer_set (&data.timer_running);
16727 }
16728 }
16729 }
16730 }
16731 // NOTE: combi is okay because it is already set beforehand
16732 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16733 {
16734 if (data.dictfile == NULL)
16735 {
16736 if (dictfiles != NULL)
16737 {
16738 hc_timer_set (&data.timer_running);
16739
16740 data.dictfile = dictfiles[0];
16741 }
16742 }
16743 }
16744 else if (attack_mode == ATTACK_MODE_BF)
16745 {
16746 if (data.mask == NULL)
16747 {
16748 hc_timer_set (&data.timer_running);
16749
16750 data.mask = masks[0];
16751 }
16752 }
16753
16754 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16755 {
16756 data.devices_status = STATUS_EXHAUSTED;
16757 }
16758
16759 // if cracked / aborted remove last induction dictionary
16760
16761 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16762 {
16763 struct stat induct_stat;
16764
16765 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16766 {
16767 unlink (induction_dictionaries[file_pos]);
16768 }
16769 }
16770
16771 // wait for non-interactive threads
16772
16773 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16774 {
16775 hc_thread_wait (1, &ni_threads[thread_idx]);
16776 }
16777
16778 local_free (ni_threads);
16779
16780 // wait for interactive threads
16781
16782 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16783 {
16784 hc_thread_wait (1, &i_thread);
16785 }
16786
16787 // we dont need restore file anymore
16788 if (data.restore_disable == 0)
16789 {
16790 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16791 {
16792 unlink (eff_restore_file);
16793 unlink (new_restore_file);
16794 }
16795 else
16796 {
16797 cycle_restore ();
16798 }
16799 }
16800
16801 // finally save left hashes
16802
16803 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16804 {
16805 save_hash ();
16806 }
16807
16808 /**
16809 * Clean up
16810 */
16811
16812 if (benchmark == 1)
16813 {
16814 status_benchmark ();
16815
16816 log_info ("");
16817 }
16818 else
16819 {
16820 if (quiet == 0) clear_prompt ();
16821
16822 if (quiet == 0) log_info ("");
16823
16824 if (status == 1)
16825 {
16826 status_display ();
16827 }
16828 else
16829 {
16830 if (quiet == 0) status_display ();
16831 }
16832
16833 if (quiet == 0) log_info ("");
16834 }
16835
16836 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16837 {
16838 hc_device_param_t *device_param = &data.devices_param[device_id];
16839
16840 if (device_param->skipped) continue;
16841
16842 local_free (device_param->result);
16843
16844 local_free (device_param->combs_buf);
16845
16846 local_free (device_param->hooks_buf);
16847
16848 local_free (device_param->device_name);
16849
16850 local_free (device_param->device_name_chksum);
16851
16852 local_free (device_param->device_version);
16853
16854 local_free (device_param->driver_version);
16855
16856 if (device_param->pws_buf) myfree (device_param->pws_buf);
16857 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
16858 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
16859 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
16860 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
16861 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
16862 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
16863 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
16864 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
16865 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
16866 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
16867 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
16868 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
16869 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
16870 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
16871 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
16872 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
16873 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
16874 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
16875 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
16876 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
16877 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
16878 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
16879 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
16880 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
16881 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
16882 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
16883 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
16884 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
16885
16886 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
16887 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
16888 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
16889 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
16890 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
16891 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
16892 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
16893 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
16894 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
16895 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
16896
16897 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
16898 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
16899 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
16900
16901 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
16902 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
16903 }
16904
16905 // reset default fan speed
16906
16907 #ifdef HAVE_HWMON
16908 if (gpu_temp_disable == 0)
16909 {
16910 #ifdef HAVE_ADL
16911 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16912 {
16913 hc_thread_mutex_lock (mux_adl);
16914
16915 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16916 {
16917 hc_device_param_t *device_param = &data.devices_param[device_id];
16918
16919 if (device_param->skipped) continue;
16920
16921 if (data.hm_device[device_id].fan_supported == 1)
16922 {
16923 int fanspeed = temp_retain_fanspeed_value[device_id];
16924
16925 if (fanspeed == -1) continue;
16926
16927 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
16928
16929 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
16930 }
16931 }
16932
16933 hc_thread_mutex_unlock (mux_adl);
16934 }
16935 #endif // HAVE_ADL
16936 }
16937
16938 #ifdef HAVE_ADL
16939 // reset power tuning
16940
16941 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16942 {
16943 hc_thread_mutex_lock (mux_adl);
16944
16945 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16946 {
16947 hc_device_param_t *device_param = &data.devices_param[device_id];
16948
16949 if (device_param->skipped) continue;
16950
16951 if (data.hm_device[device_id].od_version == 6)
16952 {
16953 // check powertune capabilities first, if not available then skip device
16954
16955 int powertune_supported = 0;
16956
16957 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
16958 {
16959 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16960
16961 return (-1);
16962 }
16963
16964 if (powertune_supported != 0)
16965 {
16966 // powercontrol settings
16967
16968 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)
16969 {
16970 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16971
16972 return (-1);
16973 }
16974
16975 // clocks
16976
16977 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16978
16979 performance_state->iNumberOfPerformanceLevels = 2;
16980
16981 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
16982 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
16983 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
16984 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
16985
16986 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)
16987 {
16988 log_info ("ERROR: Failed to restore ADL performance state");
16989
16990 return (-1);
16991 }
16992
16993 local_free (performance_state);
16994 }
16995 }
16996 }
16997
16998 hc_thread_mutex_unlock (mux_adl);
16999 }
17000 #endif // HAVE_ADL
17001
17002 if (gpu_temp_disable == 0)
17003 {
17004 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
17005 if (data.hm_nv)
17006 {
17007 #if defined(LINUX) && defined(HAVE_NVML)
17008
17009 hm_NVML_nvmlShutdown (data.hm_nv);
17010
17011 nvml_close (data.hm_nv);
17012
17013 #elif defined(WIN) && (HAVE_NVAPI)
17014
17015 hm_NvAPI_Unload (data.hm_nv);
17016
17017 nvapi_close (data.hm_nv);
17018
17019 #endif
17020
17021 data.hm_nv = NULL;
17022 }
17023 #endif
17024
17025 #ifdef HAVE_ADL
17026 if (data.hm_amd)
17027 {
17028 hm_ADL_Main_Control_Destroy (data.hm_amd);
17029
17030 adl_close (data.hm_amd);
17031 data.hm_amd = NULL;
17032 }
17033 #endif
17034 }
17035 #endif // HAVE_HWMON
17036
17037 // free memory
17038
17039 local_free (masks);
17040
17041 local_free (dictstat_base);
17042
17043 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
17044 {
17045 pot_t *pot_ptr = &pot[pot_pos];
17046
17047 hash_t *hash = &pot_ptr->hash;
17048
17049 local_free (hash->digest);
17050
17051 if (isSalted)
17052 {
17053 local_free (hash->salt);
17054 }
17055 }
17056
17057 local_free (pot);
17058
17059 local_free (all_kernel_rules_cnt);
17060 local_free (all_kernel_rules_buf);
17061
17062 local_free (wl_data->buf);
17063 local_free (wl_data);
17064
17065 local_free (bitmap_s1_a);
17066 local_free (bitmap_s1_b);
17067 local_free (bitmap_s1_c);
17068 local_free (bitmap_s1_d);
17069 local_free (bitmap_s2_a);
17070 local_free (bitmap_s2_b);
17071 local_free (bitmap_s2_c);
17072 local_free (bitmap_s2_d);
17073
17074 #ifdef HAVE_HWMON
17075 local_free (temp_retain_fanspeed_value);
17076 #ifdef HAVE_ADL
17077 local_free (od_clock_mem_status);
17078 local_free (od_power_control_status);
17079 #endif // ADL
17080 #endif
17081
17082 global_free (devices_param);
17083
17084 global_free (kernel_rules_buf);
17085
17086 global_free (root_css_buf);
17087 global_free (markov_css_buf);
17088
17089 global_free (digests_buf);
17090 global_free (digests_shown);
17091 global_free (digests_shown_tmp);
17092
17093 global_free (salts_buf);
17094 global_free (salts_shown);
17095
17096 global_free (esalts_buf);
17097
17098 global_free (words_progress_done);
17099 global_free (words_progress_rejected);
17100 global_free (words_progress_restored);
17101
17102 if (pot_fp) fclose (pot_fp);
17103
17104 if (data.devices_status == STATUS_QUIT) break;
17105 }
17106
17107 // destroy others mutex
17108
17109 hc_thread_mutex_delete (mux_dispatcher);
17110 hc_thread_mutex_delete (mux_counter);
17111 hc_thread_mutex_delete (mux_display);
17112 hc_thread_mutex_delete (mux_adl);
17113
17114 // free memory
17115
17116 local_free (eff_restore_file);
17117 local_free (new_restore_file);
17118
17119 local_free (rd);
17120
17121 // tuning db
17122
17123 tuning_db_destroy (tuning_db);
17124
17125 // loopback
17126
17127 local_free (loopback_file);
17128
17129 if (loopback == 1) unlink (loopback_file);
17130
17131 // induction directory
17132
17133 if (induction_dir == NULL)
17134 {
17135 if (attack_mode != ATTACK_MODE_BF)
17136 {
17137 if (rmdir (induction_directory) == -1)
17138 {
17139 if (errno == ENOENT)
17140 {
17141 // good, we can ignore
17142 }
17143 else if (errno == ENOTEMPTY)
17144 {
17145 // good, we can ignore
17146 }
17147 else
17148 {
17149 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
17150
17151 return (-1);
17152 }
17153 }
17154
17155 local_free (induction_directory);
17156 }
17157 }
17158
17159 // outfile-check directory
17160
17161 if (outfile_check_dir == NULL)
17162 {
17163 if (rmdir (outfile_check_directory) == -1)
17164 {
17165 if (errno == ENOENT)
17166 {
17167 // good, we can ignore
17168 }
17169 else if (errno == ENOTEMPTY)
17170 {
17171 // good, we can ignore
17172 }
17173 else
17174 {
17175 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
17176
17177 return (-1);
17178 }
17179 }
17180
17181 local_free (outfile_check_directory);
17182 }
17183
17184 time_t proc_stop;
17185
17186 time (&proc_stop);
17187
17188 logfile_top_uint (proc_start);
17189 logfile_top_uint (proc_stop);
17190
17191 logfile_top_msg ("STOP");
17192
17193 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
17194 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
17195
17196 if (data.ocl) ocl_close (data.ocl);
17197
17198 if (data.devices_status == STATUS_ABORTED) return 2;
17199 if (data.devices_status == STATUS_QUIT) return 2;
17200 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
17201 if (data.devices_status == STATUS_EXHAUSTED) return 1;
17202 if (data.devices_status == STATUS_CRACKED) return 0;
17203
17204 return -1;
17205 }
Hashcat additions to support pwdhash