projects / hashcat.git / blob
? search:


bd720e86553d8fb88048517887b7e4588923c922
[hashcat.git] / src / oclHashcat.c
1 /**
2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
5 *
6 * License.....: MIT
7 */
8
9 #ifdef OSX
10 #include <stdio.h>
11 #endif
12
13 #include <common.h>
14 #include <shared.h>
15 #include <rp_kernel_on_cpu.h>
16 #include <getopt.h>
17
18 const char *PROGNAME = "oclHashcat";
19 const uint VERSION_BIN = 210;
20 const uint RESTORE_MIN = 210;
21
22 double TARGET_MS_PROFILE[3] = { 8, 16, 96 };
23
24 #define INCR_RULES 10000
25 #define INCR_SALTS 100000
26 #define INCR_MASKS 1000
27 #define INCR_POT 1000
28
29 #define USAGE 0
30 #define VERSION 0
31 #define QUIET 0
32 #define MARKOV_THRESHOLD 0
33 #define MARKOV_DISABLE 0
34 #define MARKOV_CLASSIC 0
35 #define BENCHMARK 0
36 #define BENCHMARK_REPEATS 100
37 #define RESTORE 0
38 #define RESTORE_TIMER 60
39 #define RESTORE_DISABLE 0
40 #define STATUS 0
41 #define STATUS_TIMER 10
42 #define STATUS_AUTOMAT 0
43 #define LOOPBACK 0
44 #define WEAK_HASH_THRESHOLD 100
45 #define SHOW 0
46 #define LEFT 0
47 #define USERNAME 0
48 #define REMOVE 0
49 #define REMOVE_TIMER 60
50 #define SKIP 0
51 #define LIMIT 0
52 #define KEYSPACE 0
53 #define POTFILE_DISABLE 0
54 #define DEBUG_MODE 0
55 #define RP_GEN 0
56 #define RP_GEN_FUNC_MIN 1
57 #define RP_GEN_FUNC_MAX 4
58 #define RP_GEN_SEED 0
59 #define RULE_BUF_L ":"
60 #define RULE_BUF_R ":"
61 #define FORCE 0
62 #define RUNTIME 0
63 #define HEX_CHARSET 0
64 #define HEX_SALT 0
65 #define HEX_WORDLIST 0
66 #define OUTFILE_FORMAT 3
67 #define OUTFILE_AUTOHEX 1
68 #define OUTFILE_CHECK_TIMER 5
69 #define ATTACK_MODE 0
70 #define HASH_MODE 0
71 #define SEGMENT_SIZE 32
72 #define INCREMENT 0
73 #define INCREMENT_MIN 1
74 #define INCREMENT_MAX PW_MAX
75 #define SEPARATOR ':'
76 #define BITMAP_MIN 16
77 #define BITMAP_MAX 24
78 #define GPU_TEMP_DISABLE 0
79 #define GPU_TEMP_ABORT 90
80 #define GPU_TEMP_RETAIN 80
81 #define WORKLOAD_PROFILE 2
82 #define KERNEL_ACCEL 0
83 #define KERNEL_LOOPS 0
84 #define KERNEL_RULES 1024
85 #define KERNEL_COMBS 1024
86 #define KERNEL_BFS 1024
87 #define KERNEL_THREADS 64
88 #define POWERTUNE_ENABLE 0
89 #define LOGFILE_DISABLE 0
90 #define SCRYPT_TMTO 0
91 #define OPENCL_VECTOR_WIDTH 0
92
93 #define WL_MODE_STDIN 1
94 #define WL_MODE_FILE 2
95 #define WL_MODE_MASK 3
96
97 #define HL_MODE_FILE 4
98 #define HL_MODE_ARG 5
99
100 #define HLFMTS_CNT 11
101 #define HLFMT_HASHCAT 0
102 #define HLFMT_PWDUMP 1
103 #define HLFMT_PASSWD 2
104 #define HLFMT_SHADOW 3
105 #define HLFMT_DCC 4
106 #define HLFMT_DCC2 5
107 #define HLFMT_NETNTLM1 7
108 #define HLFMT_NETNTLM2 8
109 #define HLFMT_NSLDAP 9
110 #define HLFMT_NSLDAPS 10
111
112 #define HLFMT_TEXT_HASHCAT "native hashcat"
113 #define HLFMT_TEXT_PWDUMP "pwdump"
114 #define HLFMT_TEXT_PASSWD "passwd"
115 #define HLFMT_TEXT_SHADOW "shadow"
116 #define HLFMT_TEXT_DCC "DCC"
117 #define HLFMT_TEXT_DCC2 "DCC 2"
118 #define HLFMT_TEXT_NETNTLM1 "NetNTLMv1"
119 #define HLFMT_TEXT_NETNTLM2 "NetNTLMv2"
120 #define HLFMT_TEXT_NSLDAP "nsldap"
121 #define HLFMT_TEXT_NSLDAPS "nsldaps"
122
123 #define ATTACK_MODE_STRAIGHT 0
124 #define ATTACK_MODE_COMBI 1
125 #define ATTACK_MODE_TOGGLE 2
126 #define ATTACK_MODE_BF 3
127 #define ATTACK_MODE_PERM 4
128 #define ATTACK_MODE_TABLE 5
129 #define ATTACK_MODE_HYBRID1 6
130 #define ATTACK_MODE_HYBRID2 7
131 #define ATTACK_MODE_NONE 100
132
133 #define ATTACK_KERN_STRAIGHT 0
134 #define ATTACK_KERN_COMBI 1
135 #define ATTACK_KERN_BF 3
136 #define ATTACK_KERN_NONE 100
137
138 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
139 #define ATTACK_EXEC_INSIDE_KERNEL 11
140
141 #define COMBINATOR_MODE_BASE_LEFT 10001
142 #define COMBINATOR_MODE_BASE_RIGHT 10002
143
144 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
145 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
146
147 #define MAX_CUT_TRIES 4
148
149 #define MAX_DICTSTAT 10000
150
151 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 135
152
153 #define global_free(attr) \
154 { \
155 myfree ((void *) data.attr); \
156 \
157 data.attr = NULL; \
158 }
159
160 #define local_free(attr) \
161 { \
162 myfree ((void *) attr); \
163 \
164 attr = NULL; \
165 }
166
167 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
168 {
169 900,
170 0,
171 5100,
172 100,
173 1400,
174 10800,
175 1700,
176 5000,
177 10100,
178 6000,
179 6100,
180 6900,
181 11700,
182 11800,
183 400,
184 8900,
185 11900,
186 12000,
187 10900,
188 12100,
189 23,
190 2500,
191 5300,
192 5400,
193 5500,
194 5600,
195 7300,
196 7500,
197 13100,
198 8300,
199 11100,
200 11200,
201 11400,
202 121,
203 2611,
204 2711,
205 2811,
206 8400,
207 11,
208 2612,
209 7900,
210 21,
211 11000,
212 124,
213 10000,
214 3711,
215 7600,
216 12,
217 131,
218 132,
219 1731,
220 200,
221 300,
222 3100,
223 112,
224 12300,
225 8000,
226 141,
227 1441,
228 1600,
229 12600,
230 1421,
231 101,
232 111,
233 1711,
234 3000,
235 1000,
236 1100,
237 2100,
238 12800,
239 1500,
240 12400,
241 500,
242 3200,
243 7400,
244 1800,
245 122,
246 1722,
247 7100,
248 6300,
249 6700,
250 6400,
251 6500,
252 2400,
253 2410,
254 5700,
255 9200,
256 9300,
257 22,
258 501,
259 5800,
260 8100,
261 8500,
262 7200,
263 9900,
264 7700,
265 7800,
266 10300,
267 8600,
268 8700,
269 9100,
270 133,
271 11600,
272 12500,
273 13000,
274 13200,
275 13300,
276 6211,
277 6221,
278 6231,
279 6241,
280 8800,
281 12900,
282 12200,
283 9700,
284 9710,
285 9800,
286 9810,
287 9400,
288 9500,
289 9600,
290 10400,
291 10410,
292 10500,
293 10600,
294 10700,
295 9000,
296 5200,
297 6800,
298 6600,
299 8200,
300 11300,
301 12700,
302 13400,
303 125
304 };
305
306 /**
307 * types
308 */
309
310 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
311
312 /**
313 * globals
314 */
315
316 static unsigned int full01 = 0x01010101;
317 static unsigned int full80 = 0x80808080;
318
319 int SUPPRESS_OUTPUT = 0;
320
321 hc_thread_mutex_t mux_adl;
322 hc_thread_mutex_t mux_counter;
323 hc_thread_mutex_t mux_dispatcher;
324 hc_thread_mutex_t mux_display;
325
326 hc_global_data_t data;
327
328 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
329
330 const char *USAGE_MINI[] =
331 {
332 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
333 "",
334 "Try --help for more help.",
335 NULL
336 };
337
338 const char *USAGE_BIG[] =
339 {
340 "%s, advanced password recovery",
341 "",
342 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
343 "",
344 "=======",
345 "Options",
346 "=======",
347 "",
348 "* General:",
349 "",
350 " -m, --hash-type=NUM Hash-type, see references below",
351 " -a, --attack-mode=NUM Attack-mode, see references below",
352 " -V, --version Print version",
353 " -h, --help Print help",
354 " --quiet Suppress output",
355 "",
356 "* Misc:",
357 "",
358 " --hex-charset Assume charset is given in hex",
359 " --hex-salt Assume salt is given in hex",
360 " --hex-wordlist Assume words in wordlist is given in hex",
361 " --force Ignore warnings",
362 " --status Enable automatic update of the status-screen",
363 " --status-timer=NUM Seconds between status-screen update",
364 " --status-automat Display the status view in a machine readable format",
365 " --loopback Add new plains to induct directory",
366 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
367 "",
368 "* Markov:",
369 "",
370 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
371 " --markov-disable Disables markov-chains, emulates classic brute-force",
372 " --markov-classic Enables classic markov-chains, no per-position enhancement",
373 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
374 "",
375 "* Session:",
376 "",
377 " --runtime=NUM Abort session after NUM seconds of runtime",
378 " --session=STR Define specific session name",
379 " --restore Restore session from --session",
380 " --restore-disable Do not write restore file",
381 "",
382 "* Files:",
383 "",
384 " -o, --outfile=FILE Define outfile for recovered hash",
385 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
386 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
387 " --outfile-check-timer=NUM Seconds between outfile checks",
388 " -p, --separator=CHAR Separator char for hashlists and outfile",
389 " --show Show cracked passwords only",
390 " --left Show un-cracked passwords only",
391 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
392 " --remove Enable remove of hash once it is cracked",
393 " --remove-timer=NUM Update input hash file each NUM seconds",
394 " --potfile-disable Do not write potfile",
395 " --potfile-path Specific path to potfile",
396 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
397 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
398 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
399 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
400 " --logfile-disable Disable the logfile",
401 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
402 "",
403 "* Resources:",
404 "",
405 " -b, --benchmark Run benchmark",
406 " --benchmark-repeats=NUM Repeat the kernel on the device NUM times to increase benchmark accuracy",
407 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
408 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
409 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
410 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
411 " --opencl-platforms=STR OpenCL platforms to use, separate with comma",
412 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
413 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
414 " --opencl-vector-width=NUM OpenCL vector-width (either 1, 2, 4, 8 or 16), overrides value from device query",
415 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
416 " -n, --kernel-accel=NUM Workload tuning, increase the outer-loop step size",
417 " -u, --kernel-loops=NUM Workload tuning, increase the inner-loop step size",
418 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
419 #ifdef HAVE_HWMON
420 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
421 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
422 #ifdef HAVE_ADL
423 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
424 #endif
425 #endif
426 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
427 "",
428 "* Distributed:",
429 "",
430 " -s, --skip=NUM Skip number of words",
431 " -l, --limit=NUM Limit number of words",
432 " --keyspace Show keyspace base:mod values and quit",
433 "",
434 "* Rules:",
435 "",
436 " -j, --rule-left=RULE Single rule applied to each word from left dict",
437 " -k, --rule-right=RULE Single rule applied to each word from right dict",
438 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
439 " -g, --generate-rules=NUM Generate NUM random rules",
440 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
441 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
442 " --generate-rules-seed=NUM Force RNG seed to NUM",
443 "",
444 "* Custom charsets:",
445 "",
446 " -1, --custom-charset1=CS User-defined charsets",
447 " -2, --custom-charset2=CS Example:",
448 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
449 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
450 "",
451 "* Increment:",
452 "",
453 " -i, --increment Enable increment mode",
454 " --increment-min=NUM Start incrementing at NUM",
455 " --increment-max=NUM Stop incrementing at NUM",
456 "",
457 "==========",
458 "References",
459 "==========",
460 "",
461 "* Workload Profile:",
462 "",
463 " 1 = Interactive performance profile, kernel execution runtime to 8ms, lower latency desktop, lower speed",
464 " 2 = Default performance profile, kernel execution runtime to 16ms, economic setting",
465 " 3 = Headless performance profile, kernel execution runtime to 96ms, higher latency desktop, higher speed",
466 "",
467 "* OpenCL device-types:",
468 "",
469 " 1 = CPU devices",
470 " 2 = GPU devices",
471 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
472 "",
473 "* Outfile Formats:",
474 "",
475 " 1 = hash[:salt]",
476 " 2 = plain",
477 " 3 = hash[:salt]:plain",
478 " 4 = hex_plain",
479 " 5 = hash[:salt]:hex_plain",
480 " 6 = plain:hex_plain",
481 " 7 = hash[:salt]:plain:hex_plain",
482 " 8 = crackpos",
483 " 9 = hash[:salt]:crackpos",
484 " 10 = plain:crackpos",
485 " 11 = hash[:salt]:plain:crackpos",
486 " 12 = hex_plain:crackpos",
487 " 13 = hash[:salt]:hex_plain:crackpos",
488 " 14 = plain:hex_plain:crackpos",
489 " 15 = hash[:salt]:plain:hex_plain:crackpos",
490 "",
491 "* Debug mode output formats (for hybrid mode only, by using rules):",
492 "",
493 " 1 = save finding rule",
494 " 2 = save original word",
495 " 3 = save original word and finding rule",
496 " 4 = save original word, finding rule and modified plain",
497 "",
498 "* Built-in charsets:",
499 "",
500 " ?l = abcdefghijklmnopqrstuvwxyz",
501 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
502 " ?d = 0123456789",
503 " ?s = !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
504 " ?a = ?l?u?d?s",
505 " ?b = 0x00 - 0xff",
506 "",
507 "* Attack modes:",
508 "",
509 " 0 = Straight",
510 " 1 = Combination",
511 " 3 = Brute-force",
512 " 6 = Hybrid dict + mask",
513 " 7 = Hybrid mask + dict",
514 "",
515 "* Hash types:",
516 "",
517 "[[ Roll-your-own: Raw Hashes ]]",
518 "",
519 " 900 = MD4",
520 " 0 = MD5",
521 " 5100 = Half MD5",
522 " 100 = SHA1",
523 " 10800 = SHA-384",
524 " 1400 = SHA-256",
525 " 1700 = SHA-512",
526 " 5000 = SHA-3(Keccak)",
527 " 10100 = SipHash",
528 " 6000 = RipeMD160",
529 " 6100 = Whirlpool",
530 " 6900 = GOST R 34.11-94",
531 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
532 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
533 "",
534 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
535 "",
536 " 10 = md5($pass.$salt)",
537 " 20 = md5($salt.$pass)",
538 " 30 = md5(unicode($pass).$salt)",
539 " 40 = md5($salt.unicode($pass))",
540 " 3800 = md5($salt.$pass.$salt)",
541 " 3710 = md5($salt.md5($pass))",
542 " 2600 = md5(md5($pass)",
543 " 4300 = md5(strtoupper(md5($pass)))",
544 " 4400 = md5(sha1($pass))",
545 " 110 = sha1($pass.$salt)",
546 " 120 = sha1($salt.$pass)",
547 " 130 = sha1(unicode($pass).$salt)",
548 " 140 = sha1($salt.unicode($pass))",
549 " 4500 = sha1(sha1($pass)",
550 " 4700 = sha1(md5($pass))",
551 " 4900 = sha1($salt.$pass.$salt)",
552 " 1410 = sha256($pass.$salt)",
553 " 1420 = sha256($salt.$pass)",
554 " 1430 = sha256(unicode($pass).$salt)",
555 " 1440 = sha256($salt.unicode($pass))",
556 " 1710 = sha512($pass.$salt)",
557 " 1720 = sha512($salt.$pass)",
558 " 1730 = sha512(unicode($pass).$salt)",
559 " 1740 = sha512($salt.unicode($pass))",
560 "",
561 "[[ Roll-your-own: Authenticated Hashes ]]",
562 "",
563 " 50 = HMAC-MD5 (key = $pass)",
564 " 60 = HMAC-MD5 (key = $salt)",
565 " 150 = HMAC-SHA1 (key = $pass)",
566 " 160 = HMAC-SHA1 (key = $salt)",
567 " 1450 = HMAC-SHA256 (key = $pass)",
568 " 1460 = HMAC-SHA256 (key = $salt)",
569 " 1750 = HMAC-SHA512 (key = $pass)",
570 " 1760 = HMAC-SHA512 (key = $salt)",
571 "",
572 "[[ Generic KDF ]]",
573 "",
574 " 400 = phpass",
575 " 8900 = scrypt",
576 " 11900 = PBKDF2-HMAC-MD5",
577 " 12000 = PBKDF2-HMAC-SHA1",
578 " 10900 = PBKDF2-HMAC-SHA256",
579 " 12100 = PBKDF2-HMAC-SHA512",
580 "",
581 "[[ Network protocols, Challenge-Response ]]",
582 "",
583 " 23 = Skype",
584 " 2500 = WPA/WPA2",
585 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
586 " 5300 = IKE-PSK MD5",
587 " 5400 = IKE-PSK SHA1",
588 " 5500 = NetNTLMv1",
589 " 5500 = NetNTLMv1 + ESS",
590 " 5600 = NetNTLMv2",
591 " 7300 = IPMI2 RAKP HMAC-SHA1",
592 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
593 " 8300 = DNSSEC (NSEC3)",
594 " 10200 = Cram MD5",
595 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
596 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
597 " 11400 = SIP digest authentication (MD5)",
598 " 13100 = Kerberos 5 TGS-REP etype 23",
599 "",
600 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
601 "",
602 " 121 = SMF (Simple Machines Forum)",
603 " 400 = phpBB3",
604 " 2611 = vBulletin < v3.8.5",
605 " 2711 = vBulletin > v3.8.5",
606 " 2811 = MyBB",
607 " 2811 = IPB (Invison Power Board)",
608 " 8400 = WBB3 (Woltlab Burning Board)",
609 " 11 = Joomla < 2.5.18",
610 " 400 = Joomla > 2.5.18",
611 " 400 = Wordpress",
612 " 2612 = PHPS",
613 " 7900 = Drupal7",
614 " 21 = osCommerce",
615 " 21 = xt:Commerce",
616 " 11000 = PrestaShop",
617 " 124 = Django (SHA-1)",
618 " 10000 = Django (PBKDF2-SHA256)",
619 " 3711 = Mediawiki B type",
620 " 7600 = Redmine",
621 "",
622 "[[ Database Server ]]",
623 "",
624 " 12 = PostgreSQL",
625 " 131 = MSSQL(2000)",
626 " 132 = MSSQL(2005)",
627 " 1731 = MSSQL(2012)",
628 " 1731 = MSSQL(2014)",
629 " 200 = MySQL323",
630 " 300 = MySQL4.1/MySQL5",
631 " 3100 = Oracle H: Type (Oracle 7+)",
632 " 112 = Oracle S: Type (Oracle 11+)",
633 " 12300 = Oracle T: Type (Oracle 12+)",
634 " 8000 = Sybase ASE",
635 "",
636 "[[ HTTP, SMTP, LDAP Server ]]",
637 "",
638 " 141 = EPiServer 6.x < v4",
639 " 1441 = EPiServer 6.x > v4",
640 " 1600 = Apache $apr1$",
641 " 12600 = ColdFusion 10+",
642 " 1421 = hMailServer",
643 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
644 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
645 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
646 "",
647 "[[ Checksums ]]",
648 "",
649 " 11500 = CRC32",
650 "",
651 "[[ Operating-Systems ]]",
652 "",
653 " 3000 = LM",
654 " 1000 = NTLM",
655 " 1100 = Domain Cached Credentials (DCC), MS Cache",
656 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
657 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
658 " 1500 = descrypt, DES(Unix), Traditional DES",
659 " 12400 = BSDiCrypt, Extended DES",
660 " 500 = md5crypt $1$, MD5(Unix)",
661 " 3200 = bcrypt $2*$, Blowfish(Unix)",
662 " 7400 = sha256crypt $5$, SHA256(Unix)",
663 " 1800 = sha512crypt $6$, SHA512(Unix)",
664 " 122 = OSX v10.4",
665 " 122 = OSX v10.5",
666 " 122 = OSX v10.6",
667 " 1722 = OSX v10.7",
668 " 7100 = OSX v10.8",
669 " 7100 = OSX v10.9",
670 " 7100 = OSX v10.10",
671 " 6300 = AIX {smd5}",
672 " 6700 = AIX {ssha1}",
673 " 6400 = AIX {ssha256}",
674 " 6500 = AIX {ssha512}",
675 " 2400 = Cisco-PIX",
676 " 2410 = Cisco-ASA",
677 " 500 = Cisco-IOS $1$",
678 " 5700 = Cisco-IOS $4$",
679 " 9200 = Cisco-IOS $8$",
680 " 9300 = Cisco-IOS $9$",
681 " 22 = Juniper Netscreen/SSG (ScreenOS)",
682 " 501 = Juniper IVE",
683 " 5800 = Android PIN",
684 " 8100 = Citrix Netscaler",
685 " 8500 = RACF",
686 " 7200 = GRUB 2",
687 " 9900 = Radmin2",
688 " 125 = ArubaOS",
689 "",
690 "[[ Enterprise Application Software (EAS) ]]",
691 "",
692 " 7700 = SAP CODVN B (BCODE)",
693 " 7800 = SAP CODVN F/G (PASSCODE)",
694 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
695 " 8600 = Lotus Notes/Domino 5",
696 " 8700 = Lotus Notes/Domino 6",
697 " 9100 = Lotus Notes/Domino 8",
698 " 133 = PeopleSoft",
699 "",
700 "[[ Archives ]]",
701 "",
702 " 11600 = 7-Zip",
703 " 12500 = RAR3-hp",
704 " 13000 = RAR5",
705 " 13200 = AxCrypt",
706 " 13300 = AxCrypt in memory SHA1",
707 "",
708 "[[ Full-Disk encryptions (FDE) ]]",
709 "",
710 " 62XY = TrueCrypt 5.0+",
711 " X = 1 = PBKDF2-HMAC-RipeMD160",
712 " X = 2 = PBKDF2-HMAC-SHA512",
713 " X = 3 = PBKDF2-HMAC-Whirlpool",
714 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
715 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
716 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
717 " Y = 3 = XTS 1536 bit (Ciphers: All)",
718 " 8800 = Android FDE < v4.3",
719 " 12900 = Android FDE (Samsung DEK)",
720 " 12200 = eCryptfs",
721 "",
722 "[[ Documents ]]",
723 "",
724 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
725 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
726 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
727 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
728 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
729 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
730 " 9400 = MS Office 2007",
731 " 9500 = MS Office 2010",
732 " 9600 = MS Office 2013",
733 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
734 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
735 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
736 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
737 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
738 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
739 "",
740 "[[ Password Managers ]]",
741 "",
742 " 9000 = Password Safe v2",
743 " 5200 = Password Safe v3",
744 " 6800 = Lastpass",
745 " 6600 = 1Password, agilekeychain",
746 " 8200 = 1Password, cloudkeychain",
747 " 11300 = Bitcoin/Litecoin wallet.dat",
748 " 12700 = Blockchain, My Wallet",
749 " 13400 = Keepass 1 (AES/Twofish) and Keepass 2 (AES)",
750 "",
751 NULL
752 };
753
754 /**
755 * oclHashcat specific functions
756 */
757
758 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
759 {
760 int exec_pos = (int) device_param->exec_pos - last_num_entries;
761
762 if (exec_pos < 0) exec_pos += EXEC_CACHE;
763
764 double exec_ms_sum = 0;
765
766 int exec_ms_cnt = 0;
767
768 for (int i = 0; i < last_num_entries; i++)
769 {
770 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
771
772 if (exec_ms)
773 {
774 exec_ms_sum += exec_ms;
775
776 exec_ms_cnt++;
777 }
778 }
779
780 if (exec_ms_cnt == 0) return 0;
781
782 return exec_ms_sum / exec_ms_cnt;
783 }
784
785 void status_display_automat ()
786 {
787 FILE *out = stdout;
788
789 fprintf (out, "STATUS\t%u\t", data.devices_status);
790
791 /**
792 * speed new
793 */
794
795 fprintf (out, "SPEED\t");
796
797 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
798 {
799 hc_device_param_t *device_param = &data.devices_param[device_id];
800
801 if (device_param->skipped) continue;
802
803 u64 speed_cnt = 0;
804 double speed_ms = 0;
805
806 for (int i = 0; i < SPEED_CACHE; i++)
807 {
808 double rec_ms;
809
810 hc_timer_get (device_param->speed_rec[i], rec_ms);
811
812 if (rec_ms > SPEED_MAXAGE) continue;
813
814 speed_cnt += device_param->speed_cnt[i];
815 speed_ms += device_param->speed_ms[i];
816 }
817
818 speed_cnt /= SPEED_CACHE;
819 speed_ms /= SPEED_CACHE;
820
821 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
822 }
823
824 /**
825 * exec time
826 */
827
828 fprintf (out, "EXEC_RUNTIME\t");
829
830 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
831 {
832 hc_device_param_t *device_param = &data.devices_param[device_id];
833
834 if (device_param->skipped) continue;
835
836 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
837
838 fprintf (out, "%f\t", exec_ms_avg);
839 }
840
841 /**
842 * words_cur
843 */
844
845 u64 words_cur = get_lowest_words_done ();
846
847 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
848
849 /**
850 * counter
851 */
852
853 u64 progress_total = data.words_cnt * data.salts_cnt;
854
855 u64 all_done = 0;
856 u64 all_rejected = 0;
857 u64 all_restored = 0;
858
859 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
860 {
861 all_done += data.words_progress_done[salt_pos];
862 all_rejected += data.words_progress_rejected[salt_pos];
863 all_restored += data.words_progress_restored[salt_pos];
864 }
865
866 u64 progress_cur = all_restored + all_done + all_rejected;
867 u64 progress_end = progress_total;
868
869 u64 progress_skip = 0;
870
871 if (data.skip)
872 {
873 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
874
875 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
876 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
877 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
878 }
879
880 if (data.limit)
881 {
882 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
883
884 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
885 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
886 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
887 }
888
889 u64 progress_cur_relative_skip = progress_cur - progress_skip;
890 u64 progress_end_relative_skip = progress_end - progress_skip;
891
892 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
893
894 /**
895 * cracks
896 */
897
898 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
899 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
900
901 /**
902 * temperature
903 */
904
905 #ifdef HAVE_HWMON
906 if (data.gpu_temp_disable == 0)
907 {
908 fprintf (out, "TEMP\t");
909
910 hc_thread_mutex_lock (mux_adl);
911
912 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
913 {
914 hc_device_param_t *device_param = &data.devices_param[device_id];
915
916 if (device_param->skipped) continue;
917
918 int temp = hm_get_temperature_with_device_id (device_id);
919
920 fprintf (out, "%d\t", temp);
921 }
922
923 hc_thread_mutex_unlock (mux_adl);
924 }
925 #endif // HAVE_HWMON
926
927 /**
928 * flush
929 */
930
931 #ifdef _WIN
932 fputc ('\r', out);
933 fputc ('\n', out);
934 #endif
935
936 #ifdef _POSIX
937 fputc ('\n', out);
938 #endif
939
940 fflush (out);
941 }
942
943 void status_display ()
944 {
945 if (data.devices_status == STATUS_INIT) return;
946 if (data.devices_status == STATUS_STARTING) return;
947 if (data.devices_status == STATUS_BYPASS) return;
948
949 if (data.status_automat == 1)
950 {
951 status_display_automat ();
952
953 return;
954 }
955
956 char tmp_buf[1000] = { 0 };
957
958 uint tmp_len = 0;
959
960 log_info ("Session.Name...: %s", data.session);
961
962 char *status_type = strstatus (data.devices_status);
963
964 uint hash_mode = data.hash_mode;
965
966 char *hash_type = strhashtype (hash_mode); // not a bug
967
968 log_info ("Status.........: %s", status_type);
969
970 /**
971 * show rules
972 */
973
974 if (data.rp_files_cnt)
975 {
976 uint i;
977
978 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
979 {
980 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
981 }
982
983 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
984
985 log_info ("Rules.Type.....: %s", tmp_buf);
986
987 tmp_len = 0;
988 }
989
990 if (data.rp_gen)
991 {
992 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
993
994 if (data.rp_gen_seed)
995 {
996 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
997 }
998 }
999
1000 /**
1001 * show input
1002 */
1003
1004 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1005 {
1006 if (data.wordlist_mode == WL_MODE_FILE)
1007 {
1008 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
1009 }
1010 else if (data.wordlist_mode == WL_MODE_STDIN)
1011 {
1012 log_info ("Input.Mode.....: Pipe");
1013 }
1014 }
1015 else if (data.attack_mode == ATTACK_MODE_COMBI)
1016 {
1017 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1018 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1019 }
1020 else if (data.attack_mode == ATTACK_MODE_BF)
1021 {
1022 char *mask = data.mask;
1023
1024 if (mask != NULL)
1025 {
1026 uint mask_len = data.css_cnt;
1027
1028 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1029
1030 if (mask_len > 0)
1031 {
1032 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1033 {
1034 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1035 {
1036 mask_len -= data.salts_buf[0].salt_len;
1037 }
1038 }
1039
1040 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1041
1042 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1043 }
1044
1045 if (data.maskcnt > 1)
1046 {
1047 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1048
1049 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1050 }
1051
1052 log_info ("Input.Mode.....: %s", tmp_buf);
1053 }
1054
1055 tmp_len = 0;
1056 }
1057 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1058 {
1059 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1060 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1061 }
1062 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1063 {
1064 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1065 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1066 }
1067
1068 if (data.digests_cnt == 1)
1069 {
1070 if (data.hash_mode == 2500)
1071 {
1072 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1073
1074 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1075 (char *) data.salts_buf[0].salt_buf,
1076 wpa->orig_mac1[0],
1077 wpa->orig_mac1[1],
1078 wpa->orig_mac1[2],
1079 wpa->orig_mac1[3],
1080 wpa->orig_mac1[4],
1081 wpa->orig_mac1[5],
1082 wpa->orig_mac2[0],
1083 wpa->orig_mac2[1],
1084 wpa->orig_mac2[2],
1085 wpa->orig_mac2[3],
1086 wpa->orig_mac2[4],
1087 wpa->orig_mac2[5]);
1088 }
1089 else if (data.hash_mode == 5200)
1090 {
1091 log_info ("Hash.Target....: File (%s)", data.hashfile);
1092 }
1093 else if (data.hash_mode == 9000)
1094 {
1095 log_info ("Hash.Target....: File (%s)", data.hashfile);
1096 }
1097 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1098 {
1099 log_info ("Hash.Target....: File (%s)", data.hashfile);
1100 }
1101 else
1102 {
1103 char out_buf[HCBUFSIZ] = { 0 };
1104
1105 ascii_digest (out_buf, 0, 0);
1106
1107 // limit length
1108 if (strlen (out_buf) > 40)
1109 {
1110 out_buf[41] = '.';
1111 out_buf[42] = '.';
1112 out_buf[43] = '.';
1113 out_buf[44] = 0;
1114 }
1115
1116 log_info ("Hash.Target....: %s", out_buf);
1117 }
1118 }
1119 else
1120 {
1121 if (data.hash_mode == 3000)
1122 {
1123 char out_buf1[32] = { 0 };
1124 char out_buf2[32] = { 0 };
1125
1126 ascii_digest (out_buf1, 0, 0);
1127 ascii_digest (out_buf2, 0, 1);
1128
1129 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1130 }
1131 else
1132 {
1133 log_info ("Hash.Target....: File (%s)", data.hashfile);
1134 }
1135 }
1136
1137 log_info ("Hash.Type......: %s", hash_type);
1138
1139 /**
1140 * speed new
1141 */
1142
1143 u64 speed_cnt[DEVICES_MAX] = { 0 };
1144 double speed_ms[DEVICES_MAX] = { 0 };
1145
1146 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1147 {
1148 hc_device_param_t *device_param = &data.devices_param[device_id];
1149
1150 if (device_param->skipped) continue;
1151
1152 // we need to clear values (set to 0) because in case the device does
1153 // not get new candidates it idles around but speed display would
1154 // show it as working.
1155 // if we instantly set it to 0 after reading it happens that the
1156 // speed can be shown as zero if the users refreshes too fast.
1157 // therefore, we add a timestamp when a stat was recorded and if its
1158 // too old we will not use it
1159
1160 speed_cnt[device_id] = 0;
1161 speed_ms[device_id] = 0;
1162
1163 for (int i = 0; i < SPEED_CACHE; i++)
1164 {
1165 double rec_ms;
1166
1167 hc_timer_get (device_param->speed_rec[i], rec_ms);
1168
1169 if (rec_ms > SPEED_MAXAGE) continue;
1170
1171 speed_cnt[device_id] += device_param->speed_cnt[i];
1172 speed_ms[device_id] += device_param->speed_ms[i];
1173 }
1174
1175 speed_cnt[device_id] /= SPEED_CACHE;
1176 speed_ms[device_id] /= SPEED_CACHE;
1177 }
1178
1179 float hashes_all_ms = 0;
1180
1181 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1182
1183 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1184 {
1185 hc_device_param_t *device_param = &data.devices_param[device_id];
1186
1187 if (device_param->skipped) continue;
1188
1189 hashes_dev_ms[device_id] = 0;
1190
1191 if (speed_ms[device_id])
1192 {
1193 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1194
1195 hashes_all_ms += hashes_dev_ms[device_id];
1196 }
1197 }
1198
1199 /**
1200 * exec time
1201 */
1202
1203 double exec_all_ms[DEVICES_MAX] = { 0 };
1204
1205 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1206 {
1207 hc_device_param_t *device_param = &data.devices_param[device_id];
1208
1209 if (device_param->skipped) continue;
1210
1211 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1212
1213 exec_all_ms[device_id] = exec_ms_avg;
1214 }
1215
1216 /**
1217 * timers
1218 */
1219
1220 double ms_running = 0;
1221
1222 hc_timer_get (data.timer_running, ms_running);
1223
1224 double ms_paused = data.ms_paused;
1225
1226 if (data.devices_status == STATUS_PAUSED)
1227 {
1228 double ms_paused_tmp = 0;
1229
1230 hc_timer_get (data.timer_paused, ms_paused_tmp);
1231
1232 ms_paused += ms_paused_tmp;
1233 }
1234
1235 #ifdef WIN
1236
1237 __time64_t sec_run = ms_running / 1000;
1238
1239 #else
1240
1241 time_t sec_run = ms_running / 1000;
1242
1243 #endif
1244
1245 if (sec_run)
1246 {
1247 char display_run[32] = { 0 };
1248
1249 struct tm tm_run;
1250
1251 struct tm *tmp = NULL;
1252
1253 #ifdef WIN
1254
1255 tmp = _gmtime64 (&sec_run);
1256
1257 #else
1258
1259 tmp = gmtime (&sec_run);
1260
1261 #endif
1262
1263 if (tmp != NULL)
1264 {
1265 memset (&tm_run, 0, sizeof (tm_run));
1266
1267 memcpy (&tm_run, tmp, sizeof (tm_run));
1268
1269 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1270
1271 char *start = ctime (&data.proc_start);
1272
1273 size_t start_len = strlen (start);
1274
1275 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1276 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1277
1278 log_info ("Time.Started...: %s (%s)", start, display_run);
1279 }
1280 }
1281 else
1282 {
1283 log_info ("Time.Started...: 0 secs");
1284 }
1285
1286 /**
1287 * counters
1288 */
1289
1290 u64 progress_total = data.words_cnt * data.salts_cnt;
1291
1292 u64 all_done = 0;
1293 u64 all_rejected = 0;
1294 u64 all_restored = 0;
1295
1296 u64 progress_noneed = 0;
1297
1298 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1299 {
1300 all_done += data.words_progress_done[salt_pos];
1301 all_rejected += data.words_progress_rejected[salt_pos];
1302 all_restored += data.words_progress_restored[salt_pos];
1303
1304 // Important for ETA only
1305
1306 if (data.salts_shown[salt_pos] == 1)
1307 {
1308 const u64 all = data.words_progress_done[salt_pos]
1309 + data.words_progress_rejected[salt_pos]
1310 + data.words_progress_restored[salt_pos];
1311
1312 const u64 left = data.words_cnt - all;
1313
1314 progress_noneed += left;
1315 }
1316 }
1317
1318 u64 progress_cur = all_restored + all_done + all_rejected;
1319 u64 progress_end = progress_total;
1320
1321 u64 progress_skip = 0;
1322
1323 if (data.skip)
1324 {
1325 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1326
1327 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1328 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1329 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1330 }
1331
1332 if (data.limit)
1333 {
1334 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1335
1336 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1337 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1338 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1339 }
1340
1341 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1342 u64 progress_end_relative_skip = progress_end - progress_skip;
1343
1344 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1345 {
1346 if (data.devices_status != STATUS_CRACKED)
1347 {
1348 #ifdef WIN
1349 __time64_t sec_etc = 0;
1350 #else
1351 time_t sec_etc = 0;
1352 #endif
1353
1354 if (hashes_all_ms)
1355 {
1356 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1357
1358 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1359
1360 sec_etc = ms_left / 1000;
1361 }
1362
1363 if (sec_etc == 0)
1364 {
1365 //log_info ("Time.Estimated.: 0 secs");
1366 }
1367 else if ((u64) sec_etc > ETC_MAX)
1368 {
1369 log_info ("Time.Estimated.: > 10 Years");
1370 }
1371 else
1372 {
1373 char display_etc[32] = { 0 };
1374
1375 struct tm tm_etc;
1376
1377 struct tm *tmp = NULL;
1378
1379 #ifdef WIN
1380
1381 tmp = _gmtime64 (&sec_etc);
1382
1383 #else
1384
1385 tmp = gmtime (&sec_etc);
1386
1387 #endif
1388
1389 if (tmp != NULL)
1390 {
1391 memset (&tm_etc, 0, sizeof (tm_etc));
1392
1393 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1394
1395 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1396
1397 time_t now;
1398
1399 time (&now);
1400
1401 now += sec_etc;
1402
1403 char *etc = ctime (&now);
1404
1405 size_t etc_len = strlen (etc);
1406
1407 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1408 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1409
1410 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1411 }
1412 }
1413 }
1414 }
1415
1416 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1417 {
1418 hc_device_param_t *device_param = &data.devices_param[device_id];
1419
1420 if (device_param->skipped) continue;
1421
1422 char display_dev_cur[16] = { 0 };
1423
1424 strncpy (display_dev_cur, "0.00", 4);
1425
1426 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1427
1428 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1429 }
1430
1431 char display_all_cur[16] = { 0 };
1432
1433 strncpy (display_all_cur, "0.00", 4);
1434
1435 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1436
1437 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1438
1439 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1440 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1441
1442 log_info ("Recovered......: %u/%u (%.2f%%) Digests, %u/%u (%.2f%%) Salts", data.digests_done, data.digests_cnt, digests_percent * 100, data.salts_done, data.salts_cnt, salts_percent * 100);
1443
1444 // crack-per-time
1445
1446 if (data.digests_cnt > 100)
1447 {
1448 time_t now = time (NULL);
1449
1450 int cpt_cur_min = 0;
1451 int cpt_cur_hour = 0;
1452 int cpt_cur_day = 0;
1453
1454 for (int i = 0; i < CPT_BUF; i++)
1455 {
1456 const uint cracked = data.cpt_buf[i].cracked;
1457 const time_t timestamp = data.cpt_buf[i].timestamp;
1458
1459 if ((timestamp + 60) > now)
1460 {
1461 cpt_cur_min += cracked;
1462 }
1463
1464 if ((timestamp + 3600) > now)
1465 {
1466 cpt_cur_hour += cracked;
1467 }
1468
1469 if ((timestamp + 86400) > now)
1470 {
1471 cpt_cur_day += cracked;
1472 }
1473 }
1474
1475 double ms_real = ms_running - ms_paused;
1476
1477 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1478 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1479 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1480
1481 if ((data.cpt_start + 86400) < now)
1482 {
1483 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1484 cpt_cur_min,
1485 cpt_cur_hour,
1486 cpt_cur_day,
1487 cpt_avg_min,
1488 cpt_avg_hour,
1489 cpt_avg_day);
1490 }
1491 else if ((data.cpt_start + 3600) < now)
1492 {
1493 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1494 cpt_cur_min,
1495 cpt_cur_hour,
1496 cpt_avg_min,
1497 cpt_avg_hour,
1498 cpt_avg_day);
1499 }
1500 else if ((data.cpt_start + 60) < now)
1501 {
1502 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1503 cpt_cur_min,
1504 cpt_avg_min,
1505 cpt_avg_hour,
1506 cpt_avg_day);
1507 }
1508 else
1509 {
1510 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1511 cpt_avg_min,
1512 cpt_avg_hour,
1513 cpt_avg_day);
1514 }
1515 }
1516
1517 // Restore point
1518
1519 u64 restore_point = get_lowest_words_done ();
1520
1521 u64 restore_total = data.words_base;
1522
1523 float percent_restore = 0;
1524
1525 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1526
1527 if (progress_end_relative_skip)
1528 {
1529 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1530 {
1531 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1532 float percent_rejected = 0.0;
1533
1534 if (progress_cur)
1535 {
1536 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1537 }
1538
1539 log_info ("Progress.......: %llu/%llu (%.02f%%)", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip, percent_finished * 100);
1540 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1541
1542 if (data.restore_disable == 0)
1543 {
1544 if (percent_finished != 1)
1545 {
1546 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1547 }
1548 }
1549 }
1550 }
1551 else
1552 {
1553 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1554 {
1555 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1556 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1557
1558 if (data.restore_disable == 0)
1559 {
1560 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1561 }
1562 }
1563 else
1564 {
1565 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1566 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1567
1568 // --restore not allowed if stdin is used -- really? why?
1569
1570 //if (data.restore_disable == 0)
1571 //{
1572 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1573 //}
1574 }
1575 }
1576
1577 #ifdef HAVE_HWMON
1578 if (data.gpu_temp_disable == 0)
1579 {
1580 hc_thread_mutex_lock (mux_adl);
1581
1582 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1583 {
1584 hc_device_param_t *device_param = &data.devices_param[device_id];
1585
1586 if (device_param->skipped) continue;
1587
1588 #define HM_STR_BUF_SIZE 255
1589
1590 if (data.hm_device[device_id].fan_supported == 1)
1591 {
1592 char utilization[HM_STR_BUF_SIZE] = { 0 };
1593 char temperature[HM_STR_BUF_SIZE] = { 0 };
1594 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1595
1596 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1597 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1598
1599 if (device_param->vendor_id == VENDOR_ID_AMD)
1600 {
1601 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1602 }
1603 else if (device_param->vendor_id == VENDOR_ID_NV)
1604 {
1605 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1606 }
1607
1608 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1609 }
1610 else
1611 {
1612 char utilization[HM_STR_BUF_SIZE] = { 0 };
1613 char temperature[HM_STR_BUF_SIZE] = { 0 };
1614
1615 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1616 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1617
1618 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1619 }
1620 }
1621
1622 hc_thread_mutex_unlock (mux_adl);
1623 }
1624 #endif // HAVE_HWMON
1625 }
1626
1627 static void status_benchmark ()
1628 {
1629 if (data.devices_status == STATUS_INIT) return;
1630 if (data.devices_status == STATUS_STARTING) return;
1631
1632 if (data.words_cnt == 0) return;
1633
1634 u64 speed_cnt[DEVICES_MAX] = { 0 };
1635 double speed_ms[DEVICES_MAX] = { 0 };
1636
1637 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1638 {
1639 hc_device_param_t *device_param = &data.devices_param[device_id];
1640
1641 if (device_param->skipped) continue;
1642
1643 speed_cnt[device_id] = device_param->speed_cnt[0];
1644 speed_ms[device_id] = device_param->speed_ms[0];
1645 }
1646
1647 float hashes_all_ms = 0;
1648
1649 float hashes_dev_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 hashes_dev_ms[device_id] = 0;
1658
1659 if (speed_ms[device_id])
1660 {
1661 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1662
1663 hashes_all_ms += hashes_dev_ms[device_id];
1664 }
1665 }
1666
1667 /**
1668 * exec time
1669 */
1670
1671 double exec_all_ms[DEVICES_MAX] = { 0 };
1672
1673 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1674 {
1675 hc_device_param_t *device_param = &data.devices_param[device_id];
1676
1677 if (device_param->skipped) continue;
1678
1679 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1680
1681 exec_all_ms[device_id] = exec_ms_avg;
1682 }
1683
1684 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1685 {
1686 hc_device_param_t *device_param = &data.devices_param[device_id];
1687
1688 if (device_param->skipped) continue;
1689
1690 char display_dev_cur[16] = { 0 };
1691
1692 strncpy (display_dev_cur, "0.00", 4);
1693
1694 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1695
1696 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1697 }
1698
1699 char display_all_cur[16] = { 0 };
1700
1701 strncpy (display_all_cur, "0.00", 4);
1702
1703 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1704
1705 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1706 }
1707
1708 /**
1709 * oclHashcat -only- functions
1710 */
1711
1712 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1713 {
1714 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1715 {
1716 if (attack_kern == ATTACK_KERN_STRAIGHT)
1717 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1718 else if (attack_kern == ATTACK_KERN_COMBI)
1719 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1720 else if (attack_kern == ATTACK_KERN_BF)
1721 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1722 }
1723 else
1724 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1725 }
1726
1727 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)
1728 {
1729 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1730 {
1731 if (attack_kern == ATTACK_KERN_STRAIGHT)
1732 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1733 else if (attack_kern == ATTACK_KERN_COMBI)
1734 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1735 else if (attack_kern == ATTACK_KERN_BF)
1736 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1737 }
1738 else
1739 {
1740 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1741 }
1742 }
1743
1744 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1745 {
1746 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1747 {
1748 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1749 }
1750 else
1751 {
1752 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1753 }
1754 }
1755
1756 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)
1757 {
1758 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1759 {
1760 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1761 }
1762 else
1763 {
1764 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1765 }
1766 }
1767
1768 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1769 {
1770 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1771 }
1772
1773 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1774 {
1775 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1776 }
1777
1778 static uint convert_from_hex (char *line_buf, const uint line_len)
1779 {
1780 if (line_len & 1) return (line_len); // not in hex
1781
1782 if (data.hex_wordlist == 1)
1783 {
1784 uint i;
1785 uint j;
1786
1787 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1788 {
1789 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1790 }
1791
1792 memset (line_buf + i, 0, line_len - i);
1793
1794 return (i);
1795 }
1796 else if (line_len >= 6) // $HEX[] = 6
1797 {
1798 if (line_buf[0] != '$') return (line_len);
1799 if (line_buf[1] != 'H') return (line_len);
1800 if (line_buf[2] != 'E') return (line_len);
1801 if (line_buf[3] != 'X') return (line_len);
1802 if (line_buf[4] != '[') return (line_len);
1803 if (line_buf[line_len - 1] != ']') return (line_len);
1804
1805 uint i;
1806 uint j;
1807
1808 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1809 {
1810 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1811 }
1812
1813 memset (line_buf + i, 0, line_len - i);
1814
1815 return (i);
1816 }
1817
1818 return (line_len);
1819 }
1820
1821 static void clear_prompt ()
1822 {
1823 fputc ('\r', stdout);
1824
1825 for (size_t i = 0; i < strlen (PROMPT); i++)
1826 {
1827 fputc (' ', stdout);
1828 }
1829
1830 fputc ('\r', stdout);
1831
1832 fflush (stdout);
1833 }
1834
1835 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1836 {
1837 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);
1838 }
1839
1840 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1841 {
1842 char *outfile = data.outfile;
1843 uint quiet = data.quiet;
1844 FILE *pot_fp = data.pot_fp;
1845 uint loopback = data.loopback;
1846 uint debug_mode = data.debug_mode;
1847 char *debug_file = data.debug_file;
1848
1849 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1850 int debug_rule_len = 0; // -1 error
1851 uint debug_plain_len = 0;
1852
1853 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1854
1855 // hash
1856
1857 char out_buf[HCBUFSIZ] = { 0 };
1858
1859 ascii_digest (out_buf, salt_pos, digest_pos);
1860
1861 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1862
1863 // plain
1864
1865 plain_t plain;
1866
1867 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);
1868
1869 uint gidvid = plain.gidvid;
1870 uint il_pos = plain.il_pos;
1871
1872 u64 crackpos = device_param->words_off;
1873
1874 uint plain_buf[16] = { 0 };
1875
1876 u8 *plain_ptr = (u8 *) plain_buf;
1877 unsigned int plain_len = 0;
1878
1879 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1880 {
1881 u64 gidd = gidvid;
1882 u64 gidm = 0;
1883
1884 pw_t pw;
1885
1886 gidd_to_pw_t (device_param, gidd, &pw);
1887
1888 for (int i = 0, j = gidm; i < 16; i++, j++)
1889 {
1890 plain_buf[i] = pw.i[j];
1891 }
1892
1893 plain_len = pw.pw_len;
1894
1895 const uint off = device_param->innerloop_pos + il_pos;
1896
1897 if (debug_mode > 0)
1898 {
1899 debug_rule_len = 0;
1900
1901 // save rule
1902 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1903 {
1904 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1905
1906 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1907 }
1908
1909 // save plain
1910 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1911 {
1912 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1913
1914 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1915
1916 debug_plain_len = plain_len;
1917 }
1918 }
1919
1920 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1921
1922 crackpos += gidvid;
1923 crackpos *= data.kernel_rules_cnt;
1924 crackpos += device_param->innerloop_pos + il_pos;
1925
1926 if (plain_len > data.pw_max) plain_len = data.pw_max;
1927 }
1928 else if (data.attack_mode == ATTACK_MODE_COMBI)
1929 {
1930 u64 gidd = gidvid;
1931 u64 gidm = 0;
1932
1933 pw_t pw;
1934
1935 gidd_to_pw_t (device_param, gidd, &pw);
1936
1937 for (int i = 0, j = gidm; i < 16; i++, j++)
1938 {
1939 plain_buf[i] = pw.i[j];
1940 }
1941
1942 plain_len = pw.pw_len;
1943
1944 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1945 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1946
1947 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1948 {
1949 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1950 }
1951 else
1952 {
1953 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1954
1955 memcpy (plain_ptr, comb_buf, comb_len);
1956 }
1957
1958 plain_len += comb_len;
1959
1960 crackpos += gidvid;
1961 crackpos *= data.combs_cnt;
1962 crackpos += device_param->innerloop_pos + il_pos;
1963
1964 if (data.pw_max != PW_DICTMAX1)
1965 {
1966 if (plain_len > data.pw_max) plain_len = data.pw_max;
1967 }
1968 }
1969 else if (data.attack_mode == ATTACK_MODE_BF)
1970 {
1971 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1972 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1973
1974 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1975 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1976
1977 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1978 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1979
1980 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1981 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1982
1983 plain_len = data.css_cnt;
1984
1985 crackpos += gidvid;
1986 crackpos *= data.bfs_cnt;
1987 crackpos += device_param->innerloop_pos + il_pos;
1988 }
1989 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1990 {
1991 u64 gidd = gidvid;
1992 u64 gidm = 0;
1993
1994 pw_t pw;
1995
1996 gidd_to_pw_t (device_param, gidd, &pw);
1997
1998 for (int i = 0, j = gidm; i < 16; i++, j++)
1999 {
2000 plain_buf[i] = pw.i[j];
2001 }
2002
2003 plain_len = pw.pw_len;
2004
2005 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2006
2007 uint start = 0;
2008 uint stop = device_param->kernel_params_mp_buf32[4];
2009
2010 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2011
2012 plain_len += start + stop;
2013
2014 crackpos += gidvid;
2015 crackpos *= data.combs_cnt;
2016 crackpos += device_param->innerloop_pos + il_pos;
2017
2018 if (data.pw_max != PW_DICTMAX1)
2019 {
2020 if (plain_len > data.pw_max) plain_len = data.pw_max;
2021 }
2022 }
2023 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2024 {
2025 u64 gidd = gidvid;
2026 u64 gidm = 0;
2027
2028 pw_t pw;
2029
2030 gidd_to_pw_t (device_param, gidd, &pw);
2031
2032 for (int i = 0, j = gidm; i < 16; i++, j++)
2033 {
2034 plain_buf[i] = pw.i[j];
2035 }
2036
2037 plain_len = pw.pw_len;
2038
2039 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2040
2041 uint start = 0;
2042 uint stop = device_param->kernel_params_mp_buf32[4];
2043
2044 memmove (plain_ptr + stop, plain_ptr, plain_len);
2045
2046 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2047
2048 plain_len += start + stop;
2049
2050 crackpos += gidvid;
2051 crackpos *= data.combs_cnt;
2052 crackpos += device_param->innerloop_pos + il_pos;
2053
2054 if (data.pw_max != PW_DICTMAX1)
2055 {
2056 if (plain_len > data.pw_max) plain_len = data.pw_max;
2057 }
2058 }
2059
2060 if (data.attack_mode == ATTACK_MODE_BF)
2061 {
2062 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2063 {
2064 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2065 {
2066 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2067 {
2068 plain_len = plain_len - data.salts_buf[0].salt_len;
2069 }
2070 }
2071
2072 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2073 {
2074 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2075 {
2076 plain_ptr[j] = plain_ptr[i];
2077 }
2078
2079 plain_len = plain_len / 2;
2080 }
2081 }
2082 }
2083
2084 // if enabled, update also the potfile
2085
2086 if (pot_fp)
2087 {
2088 lock_file (pot_fp);
2089
2090 fprintf (pot_fp, "%s:", out_buf);
2091
2092 format_plain (pot_fp, plain_ptr, plain_len, 1);
2093
2094 fputc ('\n', pot_fp);
2095
2096 fflush (pot_fp);
2097
2098 unlock_file (pot_fp);
2099 }
2100
2101 // outfile
2102
2103 FILE *out_fp = NULL;
2104
2105 if (outfile != NULL)
2106 {
2107 if ((out_fp = fopen (outfile, "ab")) == NULL)
2108 {
2109 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2110
2111 out_fp = stdout;
2112 }
2113 lock_file (out_fp);
2114 }
2115 else
2116 {
2117 out_fp = stdout;
2118
2119 if (quiet == 0) clear_prompt ();
2120 }
2121
2122 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2123
2124 if (outfile != NULL)
2125 {
2126 if (out_fp != stdout)
2127 {
2128 fclose (out_fp);
2129 }
2130 }
2131 else
2132 {
2133 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2134 {
2135 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2136 {
2137 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2138 if (quiet == 0) fflush (stdout);
2139 }
2140 }
2141 }
2142
2143 // loopback
2144
2145 if (loopback)
2146 {
2147 char *loopback_file = data.loopback_file;
2148
2149 FILE *fb_fp = NULL;
2150
2151 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2152 {
2153 lock_file (fb_fp);
2154
2155 format_plain (fb_fp, plain_ptr, plain_len, 1);
2156
2157 fputc ('\n', fb_fp);
2158
2159 fclose (fb_fp);
2160 }
2161 }
2162
2163 // (rule) debug mode
2164
2165 // the next check implies that:
2166 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2167 // - debug_mode > 0
2168
2169 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2170 {
2171 if (debug_rule_len < 0) debug_rule_len = 0;
2172
2173 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2174
2175 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2176
2177 if ((quiet == 0) && (debug_file == NULL))
2178 {
2179 fprintf (stdout, "%s", PROMPT);
2180 fflush (stdout);
2181 }
2182 }
2183 }
2184
2185 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2186 {
2187 salt_t *salt_buf = &data.salts_buf[salt_pos];
2188
2189 int found = 0;
2190
2191 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);
2192
2193 for (uint i = 0; i < KERNEL_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2194
2195 if (found == 1)
2196 {
2197 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2198
2199 log_info_nn ("");
2200
2201 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);
2202
2203 uint cpt_cracked = 0;
2204
2205 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2206 {
2207 uint idx = salt_buf->digests_offset + digest_pos;
2208
2209 if (data.digests_shown_tmp[idx] == 0) continue;
2210
2211 if (data.digests_shown[idx] == 1) continue;
2212
2213 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2214 {
2215 data.digests_shown[idx] = 1;
2216
2217 data.digests_done++;
2218
2219 cpt_cracked++;
2220
2221 salt_buf->digests_done++;
2222
2223 if (salt_buf->digests_done == salt_buf->digests_cnt)
2224 {
2225 data.salts_shown[salt_pos] = 1;
2226
2227 data.salts_done++;
2228 }
2229 }
2230
2231 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2232
2233 check_hash (device_param, salt_pos, digest_pos);
2234 }
2235
2236 if (cpt_cracked > 0)
2237 {
2238 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2239 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2240
2241 data.cpt_pos++;
2242
2243 data.cpt_total += cpt_cracked;
2244
2245 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2246 }
2247
2248 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2249 {
2250 // we need to reset cracked state on the device
2251 // otherwise host thinks again and again the hash was cracked
2252 // and returns invalid password each time
2253
2254 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2255
2256 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);
2257 }
2258
2259 memset (device_param->result, 0, device_param->size_results);
2260
2261 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);
2262 }
2263 }
2264
2265 static void save_hash ()
2266 {
2267 char *hashfile = data.hashfile;
2268
2269 char new_hashfile[256] = { 0 };
2270 char old_hashfile[256] = { 0 };
2271
2272 snprintf (new_hashfile, 255, "%s.new", hashfile);
2273 snprintf (old_hashfile, 255, "%s.old", hashfile);
2274
2275 unlink (new_hashfile);
2276
2277 char separator = data.separator;
2278
2279 FILE *fp = fopen (new_hashfile, "wb");
2280
2281 if (fp == NULL)
2282 {
2283 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2284
2285 exit (-1);
2286 }
2287
2288 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2289 {
2290 if (data.salts_shown[salt_pos] == 1) continue;
2291
2292 salt_t *salt_buf = &data.salts_buf[salt_pos];
2293
2294 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2295 {
2296 uint idx = salt_buf->digests_offset + digest_pos;
2297
2298 if (data.digests_shown[idx] == 1) continue;
2299
2300 if (data.hash_mode != 2500)
2301 {
2302 char out_buf[HCBUFSIZ] = { 0 };
2303
2304 if (data.username == 1)
2305 {
2306 user_t *user = data.hash_info[idx]->user;
2307
2308 uint i;
2309
2310 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2311
2312 fputc (separator, fp);
2313 }
2314
2315 ascii_digest (out_buf, salt_pos, digest_pos);
2316
2317 fputs (out_buf, fp);
2318
2319 log_out (fp, "");
2320 }
2321 else
2322 {
2323 hccap_t hccap;
2324
2325 to_hccap_t (&hccap, salt_pos, digest_pos);
2326
2327 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2328 }
2329 }
2330 }
2331
2332 fflush (fp);
2333
2334 fclose (fp);
2335
2336 unlink (old_hashfile);
2337
2338 if (rename (hashfile, old_hashfile) != 0)
2339 {
2340 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2341
2342 exit (-1);
2343 }
2344
2345 unlink (hashfile);
2346
2347 if (rename (new_hashfile, hashfile) != 0)
2348 {
2349 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2350
2351 exit (-1);
2352 }
2353
2354 unlink (old_hashfile);
2355 }
2356
2357 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2358 {
2359 // function called only in case kernel_power_all > words_left
2360
2361 float kernel_power_div = (float) (total_left) / kernel_power_all;
2362
2363 kernel_power_div += kernel_power_div / 100;
2364
2365 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2366
2367 while (kernel_power_new < total_left)
2368 {
2369 kernel_power_div += kernel_power_div / 100;
2370
2371 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2372 }
2373
2374 if (data.quiet == 0)
2375 {
2376 clear_prompt ();
2377
2378 log_info ("");
2379
2380 log_info ("INFO: approaching final keyspace, workload adjusted");
2381
2382 log_info ("");
2383
2384 fprintf (stdout, "%s", PROMPT);
2385
2386 fflush (stdout);
2387 }
2388
2389 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2390
2391 return kernel_power_div;
2392 }
2393
2394 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2395 {
2396 uint num_elements = num;
2397
2398 device_param->kernel_params_buf32[30] = data.combs_mode;
2399 device_param->kernel_params_buf32[31] = num;
2400
2401 uint kernel_threads = device_param->kernel_threads;
2402
2403 while (num_elements % kernel_threads) num_elements++;
2404
2405 cl_kernel kernel = NULL;
2406
2407 switch (kern_run)
2408 {
2409 case KERN_RUN_1: kernel = device_param->kernel1; break;
2410 case KERN_RUN_12: kernel = device_param->kernel12; break;
2411 case KERN_RUN_2: kernel = device_param->kernel2; break;
2412 case KERN_RUN_23: kernel = device_param->kernel23; break;
2413 case KERN_RUN_3: kernel = device_param->kernel3; break;
2414 }
2415
2416 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2417 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2418 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2419 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2420 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2421 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2422 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2423 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2424 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2425 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2426 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2427
2428 hc_timer_t timer;
2429
2430 hc_timer_set (&timer);
2431
2432 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2433 {
2434 const size_t global_work_size[3] = { num_elements, 32, 1 };
2435 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2436
2437 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2438 }
2439 else
2440 {
2441 size_t workgroup_size = 0;
2442
2443 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2444
2445 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2446
2447 const size_t global_work_size[3] = { num_elements, 1, 1 };
2448 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2449
2450 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2451 }
2452
2453 hc_clFlush (data.ocl, device_param->command_queue);
2454
2455 hc_clFinish (data.ocl, device_param->command_queue);
2456
2457 if (event_update)
2458 {
2459 double exec_time;
2460
2461 hc_timer_get (timer, exec_time);
2462
2463 uint exec_pos = device_param->exec_pos;
2464
2465 device_param->exec_ms[exec_pos] = exec_time;
2466
2467 exec_pos++;
2468
2469 if (exec_pos == EXEC_CACHE)
2470 {
2471 exec_pos = 0;
2472 }
2473
2474 device_param->exec_pos = exec_pos;
2475 }
2476 }
2477
2478 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2479 {
2480 uint num_elements = num;
2481
2482 switch (kern_run)
2483 {
2484 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2485 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2486 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2487 }
2488
2489 // causes problems with special threads like in bcrypt
2490 // const uint kernel_threads = device_param->kernel_threads;
2491
2492 uint kernel_threads = KERNEL_THREADS;
2493
2494 while (num_elements % kernel_threads) num_elements++;
2495
2496 cl_kernel kernel = NULL;
2497
2498 switch (kern_run)
2499 {
2500 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2501 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2502 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2503 }
2504
2505 switch (kern_run)
2506 {
2507 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2508 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2509 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2510 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2511 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2512 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2513 break;
2514 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2515 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2516 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2517 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2518 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2519 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2520 break;
2521 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2522 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2523 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2524 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2525 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2526 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2527 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2528 break;
2529 }
2530
2531 size_t workgroup_size = 0;
2532 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), &workgroup_size, NULL);
2533 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2534
2535 const size_t global_work_size[3] = { num_elements, 1, 1 };
2536 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2537
2538 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2539
2540 hc_clFlush (data.ocl, device_param->command_queue);
2541
2542 hc_clFinish (data.ocl, device_param->command_queue);
2543 }
2544
2545 static void run_kernel_tm (hc_device_param_t *device_param)
2546 {
2547 const uint num_elements = 1024; // fixed
2548
2549 uint kernel_threads = 32;
2550
2551 cl_kernel kernel = device_param->kernel_tm;
2552
2553 size_t workgroup_size = 0;
2554 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2555 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2556
2557 const size_t global_work_size[3] = { num_elements, 1, 1 };
2558 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2559
2560 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2561
2562 hc_clFlush (data.ocl, device_param->command_queue);
2563
2564 hc_clFinish (data.ocl, device_param->command_queue);
2565 }
2566
2567 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2568 {
2569 uint num_elements = num;
2570
2571 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2572 device_param->kernel_params_amp_buf32[6] = num_elements;
2573
2574 // causes problems with special threads like in bcrypt
2575 // const uint kernel_threads = device_param->kernel_threads;
2576
2577 uint kernel_threads = KERNEL_THREADS;
2578
2579 while (num_elements % kernel_threads) num_elements++;
2580
2581 cl_kernel kernel = device_param->kernel_amp;
2582
2583 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2584 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2585
2586 size_t workgroup_size = 0;
2587 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2588 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2589
2590 const size_t global_work_size[3] = { num_elements, 1, 1 };
2591 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2592
2593 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2594
2595 hc_clFlush (data.ocl, device_param->command_queue);
2596
2597 hc_clFinish (data.ocl, device_param->command_queue);
2598 }
2599
2600 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2601 {
2602 int rc = -1;
2603
2604 if (device_param->opencl_v12 && device_param->vendor_id == VENDOR_ID_AMD)
2605 {
2606 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2607
2608 const cl_uchar zero = 0;
2609
2610 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2611 }
2612
2613 if (rc != 0)
2614 {
2615 // NOTE: clEnqueueFillBuffer () always fails with -59
2616 // IOW, it's not supported by Nvidia ForceWare <= 352.21, also pocl segfaults, also on apple
2617 // How's that possible, OpenCL 1.2 support is advertised??
2618 // We need to workaround...
2619
2620 #define FILLSZ 0x100000
2621
2622 char *tmp = (char *) mymalloc (FILLSZ);
2623
2624 for (uint i = 0; i < size; i += FILLSZ)
2625 {
2626 const int left = size - i;
2627
2628 const int fillsz = MIN (FILLSZ, left);
2629
2630 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2631 }
2632
2633 myfree (tmp);
2634 }
2635 }
2636
2637 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)
2638 {
2639 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2640 {
2641 if (attack_mode == ATTACK_MODE_BF)
2642 {
2643 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2644 {
2645 const uint size_tm = 32 * sizeof (bs_word_t);
2646
2647 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2648
2649 run_kernel_tm (device_param);
2650
2651 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);
2652 }
2653 }
2654
2655 if (highest_pw_len < 16)
2656 {
2657 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2658 }
2659 else if (highest_pw_len < 32)
2660 {
2661 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2662 }
2663 else
2664 {
2665 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2666 }
2667 }
2668 else
2669 {
2670 run_kernel_amp (device_param, pws_cnt);
2671
2672 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2673
2674 if (opts_type & OPTS_TYPE_HOOK12)
2675 {
2676 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2677 }
2678
2679 uint iter = salt_buf->salt_iter;
2680
2681 uint loop_step = device_param->kernel_loops;
2682
2683 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2684 {
2685 uint loop_left = iter - loop_pos;
2686
2687 loop_left = MIN (loop_left, loop_step);
2688
2689 device_param->kernel_params_buf32[25] = loop_pos;
2690 device_param->kernel_params_buf32[26] = loop_left;
2691
2692 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2693
2694 if (data.devices_status == STATUS_CRACKED) break;
2695 if (data.devices_status == STATUS_ABORTED) break;
2696 if (data.devices_status == STATUS_QUIT) break;
2697 }
2698
2699 if (opts_type & OPTS_TYPE_HOOK23)
2700 {
2701 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2702
2703 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);
2704
2705 // do something with data
2706
2707 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);
2708 }
2709
2710 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2711 }
2712 }
2713
2714 static int run_rule_engine (const int rule_len, const char *rule_buf)
2715 {
2716 if (rule_len == 0)
2717 {
2718 return 0;
2719 }
2720 else if (rule_len == 1)
2721 {
2722 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2723 }
2724
2725 return 1;
2726 }
2727
2728 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2729 {
2730 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2731 {
2732 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);
2733 }
2734 else if (data.attack_kern == ATTACK_KERN_COMBI)
2735 {
2736 if (data.attack_mode == ATTACK_MODE_HYBRID2)
2737 {
2738 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2739 {
2740 for (u32 i = 0; i < pws_cnt; i++)
2741 {
2742 const u32 pw_len = device_param->pws_buf[i].pw_len;
2743
2744 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2745
2746 ptr[pw_len] = 0x01;
2747 }
2748 }
2749 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2750 {
2751 for (u32 i = 0; i < pws_cnt; i++)
2752 {
2753 const u32 pw_len = device_param->pws_buf[i].pw_len;
2754
2755 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2756
2757 ptr[pw_len] = 0x80;
2758 }
2759 }
2760 }
2761
2762 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);
2763 }
2764 else if (data.attack_kern == ATTACK_KERN_BF)
2765 {
2766 const u64 off = device_param->words_off;
2767
2768 device_param->kernel_params_mp_l_buf64[3] = off;
2769
2770 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2771 }
2772 }
2773
2774 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops, const int repeat)
2775 {
2776 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2777
2778 device_param->kernel_params_buf32[26] = kernel_loops;
2779 device_param->kernel_params_buf32[27] = kernel_loops;
2780
2781 // init some fake words
2782
2783 for (u32 i = 0; i < kernel_power; i++)
2784 {
2785 device_param->pws_buf[i].i[0] = i;
2786 device_param->pws_buf[i].i[1] = 0x01234567;
2787 device_param->pws_buf[i].pw_len = 4 + (i & 3);
2788 }
2789
2790 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);
2791
2792 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2793 {
2794 run_kernel_amp (device_param, kernel_power);
2795 }
2796
2797 // caching run
2798
2799 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2800 {
2801 run_kernel (KERN_RUN_1, device_param, kernel_power, false);
2802 }
2803 else
2804 {
2805 run_kernel (KERN_RUN_2, device_param, kernel_power, false);
2806 }
2807
2808 // now user repeats
2809
2810 for (int i = 0; i < repeat; i++)
2811 {
2812 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2813 {
2814 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2815 }
2816 else
2817 {
2818 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2819 }
2820 }
2821
2822 const double exec_ms_prev = get_avg_exec_time (device_param, repeat);
2823
2824 // reset fake words
2825
2826 memset (device_param->pws_buf, 0, kernel_power * sizeof (pw_t));
2827
2828 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);
2829 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);
2830
2831 return exec_ms_prev;
2832 }
2833
2834 static void autotune (hc_device_param_t *device_param)
2835 {
2836 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2837
2838 const u32 kernel_accel_min = device_param->kernel_accel_min;
2839 const u32 kernel_accel_max = device_param->kernel_accel_max;
2840
2841 const u32 kernel_loops_min = device_param->kernel_loops_min;
2842 const u32 kernel_loops_max = device_param->kernel_loops_max;
2843
2844 u32 kernel_accel = kernel_accel_min;
2845 u32 kernel_loops = kernel_loops_min;
2846
2847 // steps
2848
2849 #define STEPS_CNT 10
2850
2851 #define STEPS_ACCEL_CNT (STEPS_CNT + 2)
2852 #define STEPS_LOOPS_CNT (STEPS_CNT + 2)
2853
2854 u32 steps_accel[STEPS_ACCEL_CNT];
2855 u32 steps_loops[STEPS_LOOPS_CNT];
2856
2857 for (int i = 0; i < STEPS_ACCEL_CNT; i++)
2858 {
2859 steps_accel[i] = 1 << i;
2860 }
2861
2862 for (int i = 0; i < STEPS_LOOPS_CNT; i++)
2863 {
2864 steps_loops[i] = 1 << i;
2865 }
2866
2867 steps_accel[STEPS_CNT + 0] = kernel_accel_min;
2868 steps_accel[STEPS_CNT + 1] = kernel_accel_max;
2869
2870 steps_loops[STEPS_CNT + 0] = kernel_loops_min;
2871 steps_loops[STEPS_CNT + 1] = kernel_loops_max;
2872
2873 qsort (steps_accel, STEPS_ACCEL_CNT, sizeof (u32), sort_by_u32);
2874 qsort (steps_loops, STEPS_LOOPS_CNT, sizeof (u32), sort_by_u32);
2875
2876 // find out highest kernel-loops that stays below target_ms, we can use it later for multiplication as this is a linear function
2877
2878 u32 kernel_loops_tmp;
2879
2880 for (kernel_loops_tmp = kernel_loops_max; kernel_loops_tmp > kernel_loops_min; kernel_loops_tmp >>= 1)
2881 {
2882 const double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops_tmp, 1);
2883
2884 if (exec_ms < target_ms) break;
2885 }
2886
2887 // kernel-accel
2888
2889 if (kernel_accel_min < kernel_accel_max)
2890 {
2891 double e_best = 0;
2892
2893 for (int i = 0; i < STEPS_ACCEL_CNT; i++)
2894 {
2895 const u32 kernel_accel_try = steps_accel[i];
2896
2897 if (kernel_accel_try < kernel_accel_min) continue;
2898 if (kernel_accel_try > kernel_accel_max) break;
2899
2900 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_tmp, 1);
2901
2902 if (exec_ms > target_ms) break;
2903
2904 const double e = kernel_accel_try / exec_ms;
2905
2906 if (e > e_best)
2907 {
2908 kernel_accel = kernel_accel_try;
2909
2910 e_best = e;
2911 }
2912 }
2913 }
2914
2915 // kernel-loops final
2916
2917 if (kernel_loops_min < kernel_loops_max)
2918 {
2919 double e_best = 0;
2920
2921 for (int i = 0; i < STEPS_LOOPS_CNT; i++)
2922 {
2923 const u32 kernel_loops_try = steps_loops[i];
2924
2925 if (kernel_loops_try < kernel_loops_min) continue;
2926 if (kernel_loops_try > kernel_loops_max) break;
2927
2928 const double exec_ms = try_run (device_param, kernel_accel, kernel_loops_try, 1);
2929
2930 if (exec_ms > target_ms) break;
2931
2932 const double e = kernel_loops_try / exec_ms;
2933
2934 if (e > e_best)
2935 {
2936 kernel_loops = kernel_loops_try;
2937
2938 e_best = e;
2939 }
2940 }
2941 }
2942
2943 // final balance
2944
2945 u32 kernel_accel_best = kernel_accel;
2946 u32 kernel_loops_best = kernel_loops;
2947
2948 u32 exec_best = -1;
2949
2950 if ((kernel_accel_min < kernel_accel_max) || (kernel_loops_min < kernel_loops_max))
2951 {
2952 const double exec_ms = try_run (device_param, kernel_accel_best, kernel_loops_best, 1);
2953
2954 exec_best = exec_ms;
2955 }
2956
2957 // reset
2958
2959 if (kernel_accel_min < kernel_accel_max)
2960 {
2961 u32 kernel_accel_try = kernel_accel;
2962 u32 kernel_loops_try = kernel_loops;
2963
2964 for (int i = 0; i < 2; i++)
2965 {
2966 kernel_accel_try >>= 1;
2967 kernel_loops_try <<= 1;
2968
2969 if (kernel_accel_try < kernel_accel_min) break;
2970 if (kernel_loops_try > kernel_loops_max) break;
2971
2972 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
2973
2974 if (exec_ms < exec_best)
2975 {
2976 kernel_accel_best = kernel_accel_try;
2977 kernel_loops_best = kernel_loops_try;
2978
2979 exec_best = exec_ms;
2980 }
2981 }
2982 }
2983
2984 // reset
2985
2986 if (kernel_loops_min < kernel_loops_max)
2987 {
2988 u32 kernel_accel_try = kernel_accel;
2989 u32 kernel_loops_try = kernel_loops;
2990
2991 for (int i = 0; i < 2; i++)
2992 {
2993 kernel_accel_try <<= 1;
2994 kernel_loops_try >>= 1;
2995
2996 if (kernel_accel_try > kernel_accel_max) break;
2997 if (kernel_loops_try < kernel_loops_min) break;
2998
2999 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
3000
3001 if (exec_ms < exec_best)
3002 {
3003 kernel_accel_best = kernel_accel_try;
3004 kernel_loops_best = kernel_loops_try;
3005
3006 exec_best = exec_ms;
3007 }
3008 }
3009 }
3010
3011 // reset timer
3012
3013 device_param->exec_pos = 0;
3014
3015 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3016
3017 // store
3018
3019 kernel_accel = kernel_accel_best;
3020 kernel_loops = kernel_loops_best;
3021
3022 device_param->kernel_accel = kernel_accel;
3023 device_param->kernel_loops = kernel_loops;
3024
3025 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3026
3027 device_param->kernel_power = kernel_power;
3028
3029 #ifdef DEBUG
3030
3031 if (data.quiet == 0)
3032 {
3033 clear_prompt ();
3034
3035 log_info ("Device #%u: autotuned kernel-accel to %u\n"
3036 "Device #%u: autotuned kernel-loops to %u\n",
3037 device_param->device_id + 1,
3038 kernel_accel,
3039 device_param->device_id + 1,
3040 kernel_loops);
3041
3042 fprintf (stdout, "%s", PROMPT);
3043 fflush (stdout);
3044 }
3045
3046 #endif
3047 }
3048
3049 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3050 {
3051 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3052
3053 // init speed timer
3054
3055 uint speed_pos = device_param->speed_pos;
3056
3057 #ifdef _POSIX
3058 if (device_param->timer_speed.tv_sec == 0)
3059 {
3060 hc_timer_set (&device_param->timer_speed);
3061 }
3062 #endif
3063
3064 #ifdef _WIN
3065 if (device_param->timer_speed.QuadPart == 0)
3066 {
3067 hc_timer_set (&device_param->timer_speed);
3068 }
3069 #endif
3070
3071 // find higest password length, this is for optimization stuff
3072
3073 uint highest_pw_len = 0;
3074
3075 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3076 {
3077 }
3078 else if (data.attack_kern == ATTACK_KERN_COMBI)
3079 {
3080 }
3081 else if (data.attack_kern == ATTACK_KERN_BF)
3082 {
3083 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3084 + device_param->kernel_params_mp_l_buf32[5];
3085 }
3086
3087 // iteration type
3088
3089 uint innerloop_step = 0;
3090 uint innerloop_cnt = 0;
3091
3092 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3093 else innerloop_step = 1;
3094
3095 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3096 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3097 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3098
3099 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3100
3101 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3102 {
3103 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3104
3105 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3106
3107 if (data.devices_status == STATUS_CRACKED) break;
3108 if (data.devices_status == STATUS_ABORTED) break;
3109 if (data.devices_status == STATUS_QUIT) break;
3110 if (data.devices_status == STATUS_BYPASS) break;
3111
3112 salt_t *salt_buf = &data.salts_buf[salt_pos];
3113
3114 device_param->kernel_params_buf32[24] = salt_pos;
3115 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3116 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3117
3118 FILE *combs_fp = device_param->combs_fp;
3119
3120 if (data.attack_mode == ATTACK_MODE_COMBI)
3121 {
3122 rewind (combs_fp);
3123 }
3124
3125 // innerloops
3126
3127 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3128 {
3129 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3130
3131 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3132
3133 if (data.devices_status == STATUS_CRACKED) break;
3134 if (data.devices_status == STATUS_ABORTED) break;
3135 if (data.devices_status == STATUS_QUIT) break;
3136 if (data.devices_status == STATUS_BYPASS) break;
3137
3138 uint innerloop_left = innerloop_cnt - innerloop_pos;
3139
3140 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3141
3142 device_param->innerloop_pos = innerloop_pos;
3143 device_param->innerloop_left = innerloop_left;
3144
3145 device_param->kernel_params_buf32[27] = innerloop_left;
3146
3147 // i think we can get rid of this
3148 if (innerloop_left == 0)
3149 {
3150 puts ("bug, how should this happen????\n");
3151
3152 continue;
3153 }
3154
3155 if (data.salts_shown[salt_pos] == 1)
3156 {
3157 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3158
3159 continue;
3160 }
3161
3162 // initialize amplifiers
3163
3164 if (data.attack_mode == ATTACK_MODE_COMBI)
3165 {
3166 uint i = 0;
3167
3168 while (i < innerloop_left)
3169 {
3170 if (feof (combs_fp)) break;
3171
3172 int line_len = fgetl (combs_fp, line_buf);
3173
3174 if (line_len >= PW_MAX1) continue;
3175
3176 line_len = convert_from_hex (line_buf, line_len);
3177
3178 char *line_buf_new = line_buf;
3179
3180 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3181 {
3182 char rule_buf_out[BLOCK_SIZE] = { 0 };
3183
3184 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3185
3186 if (rule_len_out < 0)
3187 {
3188 data.words_progress_rejected[salt_pos] += pws_cnt;
3189
3190 continue;
3191 }
3192
3193 line_len = rule_len_out;
3194
3195 line_buf_new = rule_buf_out;
3196 }
3197
3198 line_len = MIN (line_len, PW_DICTMAX);
3199
3200 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3201
3202 memcpy (ptr, line_buf_new, line_len);
3203
3204 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3205
3206 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3207 {
3208 uppercase (ptr, line_len);
3209 }
3210
3211 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3212 {
3213 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3214 {
3215 ptr[line_len] = 0x80;
3216 }
3217
3218 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3219 {
3220 ptr[line_len] = 0x01;
3221 }
3222 }
3223
3224 device_param->combs_buf[i].pw_len = line_len;
3225
3226 i++;
3227 }
3228
3229 for (uint j = i; j < innerloop_left; j++)
3230 {
3231 device_param->combs_buf[j].i[0] = 0;
3232 device_param->combs_buf[j].i[1] = 0;
3233 device_param->combs_buf[j].i[2] = 0;
3234 device_param->combs_buf[j].i[3] = 0;
3235 device_param->combs_buf[j].i[4] = 0;
3236 device_param->combs_buf[j].i[5] = 0;
3237 device_param->combs_buf[j].i[6] = 0;
3238 device_param->combs_buf[j].i[7] = 0;
3239
3240 device_param->combs_buf[j].pw_len = 0;
3241 }
3242
3243 innerloop_left = i;
3244 }
3245 else if (data.attack_mode == ATTACK_MODE_BF)
3246 {
3247 u64 off = innerloop_pos;
3248
3249 device_param->kernel_params_mp_r_buf64[3] = off;
3250
3251 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3252 }
3253 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3254 {
3255 u64 off = innerloop_pos;
3256
3257 device_param->kernel_params_mp_buf64[3] = off;
3258
3259 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3260 }
3261 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3262 {
3263 u64 off = innerloop_pos;
3264
3265 device_param->kernel_params_mp_buf64[3] = off;
3266
3267 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3268 }
3269
3270 // copy amplifiers
3271
3272 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3273 {
3274 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);
3275 }
3276 else if (data.attack_mode == ATTACK_MODE_COMBI)
3277 {
3278 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);
3279 }
3280 else if (data.attack_mode == ATTACK_MODE_BF)
3281 {
3282 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);
3283 }
3284 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3285 {
3286 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);
3287 }
3288 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3289 {
3290 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);
3291 }
3292
3293 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3294
3295 if (data.benchmark == 1)
3296 {
3297 double exec_ms_avg_prev = get_avg_exec_time (device_param, EXEC_CACHE);
3298
3299 // a few caching rounds
3300
3301 for (u32 i = 0; i < 2; i++)
3302 {
3303 hc_timer_set (&device_param->timer_speed);
3304
3305 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3306
3307 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
3308
3309 exec_ms_avg_prev = exec_ms_avg;
3310 }
3311
3312 // benchmark_repeats became a maximum possible repeats
3313
3314 for (u32 i = 2; i < data.benchmark_repeats; i++)
3315 {
3316 hc_timer_set (&device_param->timer_speed);
3317
3318 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3319
3320 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
3321
3322 if ((exec_ms_avg_prev / exec_ms_avg) < 1.001) break;
3323
3324 exec_ms_avg_prev = exec_ms_avg;
3325 }
3326 }
3327
3328 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3329
3330 if (data.devices_status == STATUS_CRACKED) break;
3331 if (data.devices_status == STATUS_ABORTED) break;
3332 if (data.devices_status == STATUS_QUIT) break;
3333
3334 /**
3335 * result
3336 */
3337
3338 hc_thread_mutex_lock (mux_display);
3339
3340 check_cracked (device_param, salt_pos);
3341
3342 hc_thread_mutex_unlock (mux_display);
3343
3344 /**
3345 * progress
3346 */
3347
3348 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3349
3350 hc_thread_mutex_lock (mux_counter);
3351
3352 data.words_progress_done[salt_pos] += perf_sum_all;
3353
3354 hc_thread_mutex_unlock (mux_counter);
3355
3356 /**
3357 * speed
3358 */
3359
3360 double speed_ms;
3361
3362 hc_timer_get (device_param->timer_speed, speed_ms);
3363
3364 hc_timer_set (&device_param->timer_speed);
3365
3366 hc_thread_mutex_lock (mux_display);
3367
3368 // current speed
3369
3370 device_param->speed_cnt[speed_pos] = perf_sum_all;
3371
3372 device_param->speed_ms[speed_pos] = speed_ms;
3373
3374 device_param->speed_rec[speed_pos] = device_param->timer_speed;
3375
3376 hc_thread_mutex_unlock (mux_display);
3377
3378 speed_pos++;
3379
3380 if (speed_pos == SPEED_CACHE)
3381 {
3382 speed_pos = 0;
3383 }
3384
3385 // average speed
3386
3387 device_param->speed_cnt_total += perf_sum_all;
3388
3389 device_param->speed_ms_total += speed_ms;
3390
3391 /**
3392 * benchmark
3393 */
3394
3395 if (data.benchmark == 1) break;
3396 }
3397 }
3398
3399 device_param->speed_pos = speed_pos;
3400
3401 myfree (line_buf);
3402 }
3403
3404 static void load_segment (wl_data_t *wl_data, FILE *fd)
3405 {
3406 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3407
3408 wl_data->pos = 0;
3409
3410 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3411
3412 wl_data->buf[wl_data->cnt] = 0;
3413
3414 if (wl_data->cnt == 0) return;
3415
3416 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3417
3418 while (!feof (fd))
3419 {
3420 if (wl_data->cnt == wl_data->avail)
3421 {
3422 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3423
3424 wl_data->avail += wl_data->incr;
3425 }
3426
3427 const int c = fgetc (fd);
3428
3429 if (c == EOF) break;
3430
3431 wl_data->buf[wl_data->cnt] = (char) c;
3432
3433 wl_data->cnt++;
3434
3435 if (c == '\n') break;
3436 }
3437
3438 // ensure stream ends with a newline
3439
3440 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3441 {
3442 wl_data->cnt++;
3443
3444 wl_data->buf[wl_data->cnt - 1] = '\n';
3445 }
3446
3447 return;
3448 }
3449
3450 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3451 {
3452 char *ptr = buf;
3453
3454 for (u32 i = 0; i < sz; i++, ptr++)
3455 {
3456 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3457
3458 if (i == 7)
3459 {
3460 *off = i;
3461 *len = i;
3462
3463 return;
3464 }
3465
3466 if (*ptr != '\n') continue;
3467
3468 *off = i + 1;
3469
3470 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3471
3472 *len = i;
3473
3474 return;
3475 }
3476
3477 *off = sz;
3478 *len = sz;
3479 }
3480
3481 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3482 {
3483 char *ptr = buf;
3484
3485 for (u32 i = 0; i < sz; i++, ptr++)
3486 {
3487 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3488
3489 if (*ptr != '\n') continue;
3490
3491 *off = i + 1;
3492
3493 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3494
3495 *len = i;
3496
3497 return;
3498 }
3499
3500 *off = sz;
3501 *len = sz;
3502 }
3503
3504 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3505 {
3506 char *ptr = buf;
3507
3508 for (u32 i = 0; i < sz; i++, ptr++)
3509 {
3510 if (*ptr != '\n') continue;
3511
3512 *off = i + 1;
3513
3514 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3515
3516 *len = i;
3517
3518 return;
3519 }
3520
3521 *off = sz;
3522 *len = sz;
3523 }
3524
3525 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3526 {
3527 while (wl_data->pos < wl_data->cnt)
3528 {
3529 uint off;
3530 uint len;
3531
3532 char *ptr = wl_data->buf + wl_data->pos;
3533
3534 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3535
3536 wl_data->pos += off;
3537
3538 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3539 {
3540 char rule_buf_out[BLOCK_SIZE] = { 0 };
3541
3542 int rule_len_out = -1;
3543
3544 if (len < BLOCK_SIZE)
3545 {
3546 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3547 }
3548
3549 if (rule_len_out < 0)
3550 {
3551 continue;
3552 }
3553
3554 if (rule_len_out > PW_MAX)
3555 {
3556 continue;
3557 }
3558 }
3559 else
3560 {
3561 if (len > PW_MAX)
3562 {
3563 continue;
3564 }
3565 }
3566
3567 *out_buf = ptr;
3568 *out_len = len;
3569
3570 return;
3571 }
3572
3573 if (feof (fd))
3574 {
3575 fprintf (stderr, "BUG feof()!!\n");
3576
3577 return;
3578 }
3579
3580 load_segment (wl_data, fd);
3581
3582 get_next_word (wl_data, fd, out_buf, out_len);
3583 }
3584
3585 #ifdef _POSIX
3586 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3587 #endif
3588
3589 #ifdef _WIN
3590 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3591 #endif
3592 {
3593 hc_signal (NULL);
3594
3595 dictstat_t d;
3596
3597 d.cnt = 0;
3598
3599 #ifdef _POSIX
3600 fstat (fileno (fd), &d.stat);
3601 #endif
3602
3603 #ifdef _WIN
3604 _fstat64 (fileno (fd), &d.stat);
3605 #endif
3606
3607 d.stat.st_mode = 0;
3608 d.stat.st_nlink = 0;
3609 d.stat.st_uid = 0;
3610 d.stat.st_gid = 0;
3611 d.stat.st_rdev = 0;
3612 d.stat.st_atime = 0;
3613
3614 #ifdef _POSIX
3615 d.stat.st_blksize = 0;
3616 d.stat.st_blocks = 0;
3617 #endif
3618
3619 if (d.stat.st_size == 0) return 0;
3620
3621 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3622
3623 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3624 {
3625 if (d_cache)
3626 {
3627 u64 cnt = d_cache->cnt;
3628
3629 u64 keyspace = cnt;
3630
3631 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3632 {
3633 keyspace *= data.kernel_rules_cnt;
3634 }
3635 else if (data.attack_kern == ATTACK_KERN_COMBI)
3636 {
3637 keyspace *= data.combs_cnt;
3638 }
3639
3640 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);
3641 if (data.quiet == 0) log_info ("");
3642
3643 hc_signal (sigHandler_default);
3644
3645 return (keyspace);
3646 }
3647 }
3648
3649 time_t now = 0;
3650 time_t prev = 0;
3651
3652 u64 comp = 0;
3653 u64 cnt = 0;
3654 u64 cnt2 = 0;
3655
3656 while (!feof (fd))
3657 {
3658 load_segment (wl_data, fd);
3659
3660 comp += wl_data->cnt;
3661
3662 u32 i = 0;
3663
3664 while (i < wl_data->cnt)
3665 {
3666 u32 len;
3667 u32 off;
3668
3669 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3670
3671 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3672 {
3673 char rule_buf_out[BLOCK_SIZE] = { 0 };
3674
3675 int rule_len_out = -1;
3676
3677 if (len < BLOCK_SIZE)
3678 {
3679 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3680 }
3681
3682 if (rule_len_out < 0)
3683 {
3684 len = PW_MAX1;
3685 }
3686 else
3687 {
3688 len = rule_len_out;
3689 }
3690 }
3691
3692 if (len < PW_MAX1)
3693 {
3694 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3695 {
3696 cnt += data.kernel_rules_cnt;
3697 }
3698 else if (data.attack_kern == ATTACK_KERN_COMBI)
3699 {
3700 cnt += data.combs_cnt;
3701 }
3702
3703 d.cnt++;
3704 }
3705
3706 i += off;
3707
3708 cnt2++;
3709 }
3710
3711 time (&now);
3712
3713 if ((now - prev) == 0) continue;
3714
3715 float percent = (float) comp / (float) d.stat.st_size;
3716
3717 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);
3718
3719 time (&prev);
3720 }
3721
3722 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);
3723 if (data.quiet == 0) log_info ("");
3724
3725 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3726
3727 hc_signal (sigHandler_default);
3728
3729 return (cnt);
3730 }
3731
3732 static void *thread_monitor (void *p)
3733 {
3734 uint runtime_check = 0;
3735 uint remove_check = 0;
3736 uint status_check = 0;
3737 uint restore_check = 0;
3738
3739 uint restore_left = data.restore_timer;
3740 uint remove_left = data.remove_timer;
3741 uint status_left = data.status_timer;
3742
3743 #ifdef HAVE_HWMON
3744 uint hwmon_check = 0;
3745
3746 // these variables are mainly used for fan control (AMD only)
3747
3748 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3749
3750 // temperature controller "loopback" values
3751
3752 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3753 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3754
3755 #ifdef HAVE_ADL
3756 int temp_threshold = 1; // degrees celcius
3757
3758 int fan_speed_min = 15; // in percentage
3759 int fan_speed_max = 100;
3760 #endif // HAVE_ADL
3761
3762 time_t last_temp_check_time;
3763 #endif // HAVE_HWMON
3764
3765 uint sleep_time = 1;
3766
3767 if (data.runtime)
3768 {
3769 runtime_check = 1;
3770 }
3771
3772 if (data.restore_timer)
3773 {
3774 restore_check = 1;
3775 }
3776
3777 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3778 {
3779 remove_check = 1;
3780 }
3781
3782 if (data.status == 1)
3783 {
3784 status_check = 1;
3785 }
3786
3787 #ifdef HAVE_HWMON
3788 if (data.gpu_temp_disable == 0)
3789 {
3790 time (&last_temp_check_time);
3791
3792 hwmon_check = 1;
3793 }
3794 #endif
3795
3796 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3797 {
3798 #ifdef HAVE_HWMON
3799 if (hwmon_check == 0)
3800 #endif
3801 return (p);
3802 }
3803
3804 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3805 {
3806 hc_sleep (sleep_time);
3807
3808 if (data.devices_status != STATUS_RUNNING) continue;
3809
3810 #ifdef HAVE_HWMON
3811 if (hwmon_check == 1)
3812 {
3813 hc_thread_mutex_lock (mux_adl);
3814
3815 time_t temp_check_time;
3816
3817 time (&temp_check_time);
3818
3819 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3820
3821 if (Ta == 0) Ta = 1;
3822
3823 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3824 {
3825 hc_device_param_t *device_param = &data.devices_param[device_id];
3826
3827 if (device_param->skipped) continue;
3828
3829 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3830
3831 const int temperature = hm_get_temperature_with_device_id (device_id);
3832
3833 if (temperature > (int) data.gpu_temp_abort)
3834 {
3835 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3836
3837 if (data.devices_status != STATUS_QUIT) myabort ();
3838
3839 break;
3840 }
3841
3842 #ifdef HAVE_ADL
3843 const int gpu_temp_retain = data.gpu_temp_retain;
3844
3845 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3846 {
3847 if (data.hm_device[device_id].fan_supported == 1)
3848 {
3849 int temp_cur = temperature;
3850
3851 int temp_diff_new = gpu_temp_retain - temp_cur;
3852
3853 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3854
3855 // calculate Ta value (time difference in seconds between the last check and this check)
3856
3857 last_temp_check_time = temp_check_time;
3858
3859 float Kp = 1.8;
3860 float Ki = 0.005;
3861 float Kd = 6;
3862
3863 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3864
3865 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);
3866
3867 if (abs (fan_diff_required) >= temp_threshold)
3868 {
3869 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3870
3871 int fan_speed_level = fan_speed_cur;
3872
3873 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3874
3875 int fan_speed_new = fan_speed_level - fan_diff_required;
3876
3877 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3878 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3879
3880 if (fan_speed_new != fan_speed_cur)
3881 {
3882 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3883 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3884
3885 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3886 {
3887 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3888
3889 fan_speed_chgd[device_id] = 1;
3890 }
3891
3892 temp_diff_old[device_id] = temp_diff_new;
3893 }
3894 }
3895 }
3896 }
3897 #endif // HAVE_ADL
3898 }
3899
3900 hc_thread_mutex_unlock (mux_adl);
3901 }
3902 #endif // HAVE_HWMON
3903
3904 if (restore_check == 1)
3905 {
3906 restore_left--;
3907
3908 if (restore_left == 0)
3909 {
3910 if (data.restore_disable == 0) cycle_restore ();
3911
3912 restore_left = data.restore_timer;
3913 }
3914 }
3915
3916 if ((runtime_check == 1) && (data.runtime_start > 0))
3917 {
3918 time_t runtime_cur;
3919
3920 time (&runtime_cur);
3921
3922 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3923
3924 if (runtime_left <= 0)
3925 {
3926 if (data.benchmark == 0)
3927 {
3928 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3929 }
3930
3931 if (data.devices_status != STATUS_QUIT) myabort ();
3932 }
3933 }
3934
3935 if (remove_check == 1)
3936 {
3937 remove_left--;
3938
3939 if (remove_left == 0)
3940 {
3941 if (data.digests_saved != data.digests_done)
3942 {
3943 data.digests_saved = data.digests_done;
3944
3945 save_hash ();
3946 }
3947
3948 remove_left = data.remove_timer;
3949 }
3950 }
3951
3952 if (status_check == 1)
3953 {
3954 status_left--;
3955
3956 if (status_left == 0)
3957 {
3958 hc_thread_mutex_lock (mux_display);
3959
3960 if (data.quiet == 0) clear_prompt ();
3961
3962 if (data.quiet == 0) log_info ("");
3963
3964 status_display ();
3965
3966 if (data.quiet == 0) log_info ("");
3967
3968 hc_thread_mutex_unlock (mux_display);
3969
3970 status_left = data.status_timer;
3971 }
3972 }
3973 }
3974
3975 #ifdef HAVE_HWMON
3976 myfree (fan_speed_chgd);
3977
3978 myfree (temp_diff_old);
3979 myfree (temp_diff_sum);
3980 #endif
3981
3982 p = NULL;
3983
3984 return (p);
3985 }
3986
3987 static void *thread_outfile_remove (void *p)
3988 {
3989 // some hash-dependent constants
3990 char *outfile_dir = data.outfile_check_directory;
3991 uint dgst_size = data.dgst_size;
3992 uint isSalted = data.isSalted;
3993 uint esalt_size = data.esalt_size;
3994 uint hash_mode = data.hash_mode;
3995
3996 uint outfile_check_timer = data.outfile_check_timer;
3997
3998 char separator = data.separator;
3999
4000 // some hash-dependent functions
4001 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4002 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4003
4004 // buffers
4005 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4006
4007 hash_buf.digest = mymalloc (dgst_size);
4008
4009 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4010
4011 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4012
4013 uint digest_buf[64] = { 0 };
4014
4015 outfile_data_t *out_info = NULL;
4016
4017 char **out_files = NULL;
4018
4019 time_t folder_mtime = 0;
4020
4021 int out_cnt = 0;
4022
4023 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4024
4025 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4026 {
4027 hc_sleep (1);
4028
4029 if (data.devices_status != STATUS_RUNNING) continue;
4030
4031 check_left--;
4032
4033 if (check_left == 0)
4034 {
4035 struct stat outfile_check_stat;
4036
4037 if (stat (outfile_dir, &outfile_check_stat) == 0)
4038 {
4039 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4040
4041 if (is_dir == 1)
4042 {
4043 if (outfile_check_stat.st_mtime > folder_mtime)
4044 {
4045 char **out_files_new = scan_directory (outfile_dir);
4046
4047 int out_cnt_new = count_dictionaries (out_files_new);
4048
4049 outfile_data_t *out_info_new = NULL;
4050
4051 if (out_cnt_new > 0)
4052 {
4053 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4054
4055 for (int i = 0; i < out_cnt_new; i++)
4056 {
4057 out_info_new[i].file_name = out_files_new[i];
4058
4059 // check if there are files that we have seen/checked before (and not changed)
4060
4061 for (int j = 0; j < out_cnt; j++)
4062 {
4063 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4064 {
4065 struct stat outfile_stat;
4066
4067 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4068 {
4069 if (outfile_stat.st_ctime == out_info[j].ctime)
4070 {
4071 out_info_new[i].ctime = out_info[j].ctime;
4072 out_info_new[i].seek = out_info[j].seek;
4073 }
4074 }
4075 }
4076 }
4077 }
4078 }
4079
4080 local_free (out_info);
4081 local_free (out_files);
4082
4083 out_files = out_files_new;
4084 out_cnt = out_cnt_new;
4085 out_info = out_info_new;
4086
4087 folder_mtime = outfile_check_stat.st_mtime;
4088 }
4089
4090 for (int j = 0; j < out_cnt; j++)
4091 {
4092 FILE *fp = fopen (out_info[j].file_name, "rb");
4093
4094 if (fp != NULL)
4095 {
4096 //hc_thread_mutex_lock (mux_display);
4097
4098 #ifdef _POSIX
4099 struct stat outfile_stat;
4100
4101 fstat (fileno (fp), &outfile_stat);
4102 #endif
4103
4104 #ifdef _WIN
4105 struct stat64 outfile_stat;
4106
4107 _fstat64 (fileno (fp), &outfile_stat);
4108 #endif
4109
4110 if (outfile_stat.st_ctime > out_info[j].ctime)
4111 {
4112 out_info[j].ctime = outfile_stat.st_ctime;
4113 out_info[j].seek = 0;
4114 }
4115
4116 fseek (fp, out_info[j].seek, SEEK_SET);
4117
4118 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4119
4120 while (!feof (fp))
4121 {
4122 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4123
4124 if (ptr == NULL) break;
4125
4126 int line_len = strlen (line_buf);
4127
4128 if (line_len <= 0) continue;
4129
4130 int iter = MAX_CUT_TRIES;
4131
4132 for (uint i = line_len - 1; i && iter; i--, line_len--)
4133 {
4134 if (line_buf[i] != separator) continue;
4135
4136 int parser_status = PARSER_OK;
4137
4138 if ((hash_mode != 2500) && (hash_mode != 6800))
4139 {
4140 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4141 }
4142
4143 uint found = 0;
4144
4145 if (parser_status == PARSER_OK)
4146 {
4147 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4148 {
4149 if (data.salts_shown[salt_pos] == 1) continue;
4150
4151 salt_t *salt_buf = &data.salts_buf[salt_pos];
4152
4153 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4154 {
4155 uint idx = salt_buf->digests_offset + digest_pos;
4156
4157 if (data.digests_shown[idx] == 1) continue;
4158
4159 uint cracked = 0;
4160
4161 if (hash_mode == 6800)
4162 {
4163 if (i == salt_buf->salt_len)
4164 {
4165 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4166 }
4167 }
4168 else if (hash_mode == 2500)
4169 {
4170 // BSSID : MAC1 : MAC2 (:plain)
4171 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4172 {
4173 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4174
4175 if (!cracked) continue;
4176
4177 // now compare MAC1 and MAC2 too, since we have this additional info
4178 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4179 char *mac2_pos = mac1_pos + 12 + 1;
4180
4181 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4182 wpa_t *wpa = &wpas[salt_pos];
4183
4184 // compare hex string(s) vs binary MAC address(es)
4185
4186 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4187 {
4188 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4189 {
4190 cracked = 0;
4191
4192 break;
4193 }
4194 }
4195
4196 // early skip ;)
4197 if (!cracked) continue;
4198
4199 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4200 {
4201 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4202 {
4203 cracked = 0;
4204
4205 break;
4206 }
4207 }
4208 }
4209 }
4210 else
4211 {
4212 char *digests_buf_ptr = (char *) data.digests_buf;
4213
4214 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4215
4216 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4217 }
4218
4219 if (cracked == 1)
4220 {
4221 found = 1;
4222
4223 data.digests_shown[idx] = 1;
4224
4225 data.digests_done++;
4226
4227 salt_buf->digests_done++;
4228
4229 if (salt_buf->digests_done == salt_buf->digests_cnt)
4230 {
4231 data.salts_shown[salt_pos] = 1;
4232
4233 data.salts_done++;
4234
4235 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4236 }
4237 }
4238 }
4239
4240 if (data.devices_status == STATUS_CRACKED) break;
4241 }
4242 }
4243
4244 if (found) break;
4245
4246 if (data.devices_status == STATUS_CRACKED) break;
4247
4248 iter--;
4249 }
4250
4251 if (data.devices_status == STATUS_CRACKED) break;
4252 }
4253
4254 myfree (line_buf);
4255
4256 out_info[j].seek = ftell (fp);
4257
4258 //hc_thread_mutex_unlock (mux_display);
4259
4260 fclose (fp);
4261 }
4262 }
4263 }
4264 }
4265
4266 check_left = outfile_check_timer;
4267 }
4268 }
4269
4270 if (esalt_size) local_free (hash_buf.esalt);
4271
4272 if (isSalted) local_free (hash_buf.salt);
4273
4274 local_free (hash_buf.digest);
4275
4276 local_free (out_info);
4277
4278 local_free (out_files);
4279
4280 p = NULL;
4281
4282 return (p);
4283 }
4284
4285 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4286 {
4287 if (device_param->pws_cnt < device_param->kernel_power)
4288 {
4289 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4290
4291 u8 *ptr = (u8 *) pw->i;
4292
4293 memcpy (ptr, pw_buf, pw_len);
4294
4295 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4296
4297 pw->pw_len = pw_len;
4298
4299 device_param->pws_cnt++;
4300 }
4301 else
4302 {
4303 fprintf (stderr, "BUG pw_add()!!\n");
4304
4305 return;
4306 }
4307 }
4308
4309 static uint get_work (hc_device_param_t *device_param, const u64 max, const bool allow_div)
4310 {
4311 hc_thread_mutex_lock (mux_dispatcher);
4312
4313 const u64 words_cur = data.words_cur;
4314 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4315
4316 device_param->words_off = words_cur;
4317
4318 const u64 words_left = words_base - words_cur;
4319
4320 if (allow_div)
4321 {
4322 if (data.kernel_power_all > words_left)
4323 {
4324 if (data.kernel_power_div == 0)
4325 {
4326 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4327 }
4328 }
4329
4330 if (data.kernel_power_div)
4331 {
4332 if (device_param->kernel_power == device_param->kernel_power_user)
4333 {
4334 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4335
4336 if (kernel_power_new < device_param->kernel_power)
4337 {
4338 device_param->kernel_power = kernel_power_new;
4339 }
4340 }
4341 }
4342 }
4343
4344 const uint kernel_power = device_param->kernel_power;
4345
4346 uint work = MIN (words_left, kernel_power);
4347
4348 work = MIN (work, max);
4349
4350 data.words_cur += work;
4351
4352 hc_thread_mutex_unlock (mux_dispatcher);
4353
4354 return work;
4355 }
4356
4357 static void *thread_calc_stdin (void *p)
4358 {
4359 hc_device_param_t *device_param = (hc_device_param_t *) p;
4360
4361 if (device_param->skipped) return NULL;
4362
4363 autotune (device_param);
4364
4365 char *buf = (char *) mymalloc (HCBUFSIZ);
4366
4367 const uint attack_kern = data.attack_kern;
4368
4369 const uint kernel_power = device_param->kernel_power;
4370
4371 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4372 {
4373 hc_thread_mutex_lock (mux_dispatcher);
4374
4375 if (feof (stdin) != 0)
4376 {
4377 hc_thread_mutex_unlock (mux_dispatcher);
4378
4379 break;
4380 }
4381
4382 uint words_cur = 0;
4383
4384 while (words_cur < kernel_power)
4385 {
4386 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4387
4388 if (line_buf == NULL) break;
4389
4390 uint line_len = in_superchop (line_buf);
4391
4392 line_len = convert_from_hex (line_buf, line_len);
4393
4394 // post-process rule engine
4395
4396 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4397 {
4398 char rule_buf_out[BLOCK_SIZE] = { 0 };
4399
4400 int rule_len_out = -1;
4401
4402 if (line_len < BLOCK_SIZE)
4403 {
4404 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4405 }
4406
4407 if (rule_len_out < 0) continue;
4408
4409 line_buf = rule_buf_out;
4410 line_len = rule_len_out;
4411 }
4412
4413 if (line_len > PW_MAX)
4414 {
4415 continue;
4416 }
4417
4418 if (attack_kern == ATTACK_KERN_STRAIGHT)
4419 {
4420 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4421 {
4422 hc_thread_mutex_lock (mux_counter);
4423
4424 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4425 {
4426 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4427 }
4428
4429 hc_thread_mutex_unlock (mux_counter);
4430
4431 continue;
4432 }
4433 }
4434 else if (attack_kern == ATTACK_KERN_COMBI)
4435 {
4436 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4437 // since we still need to combine the plains
4438
4439 if (line_len > data.pw_max)
4440 {
4441 hc_thread_mutex_lock (mux_counter);
4442
4443 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4444 {
4445 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4446 }
4447
4448 hc_thread_mutex_unlock (mux_counter);
4449
4450 continue;
4451 }
4452 }
4453
4454 pw_add (device_param, (u8 *) line_buf, line_len);
4455
4456 words_cur++;
4457
4458 if (data.devices_status == STATUS_CRACKED) break;
4459 if (data.devices_status == STATUS_ABORTED) break;
4460 if (data.devices_status == STATUS_QUIT) break;
4461 if (data.devices_status == STATUS_BYPASS) break;
4462 }
4463
4464 hc_thread_mutex_unlock (mux_dispatcher);
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 // flush
4472
4473 const uint pws_cnt = device_param->pws_cnt;
4474
4475 if (pws_cnt)
4476 {
4477 run_copy (device_param, pws_cnt);
4478
4479 run_cracker (device_param, pws_cnt);
4480
4481 device_param->pws_cnt = 0;
4482
4483 if (attack_kern == ATTACK_KERN_STRAIGHT)
4484 {
4485 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4486 }
4487 else if (attack_kern == ATTACK_KERN_COMBI)
4488 {
4489 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4490 }
4491 }
4492 }
4493
4494 device_param->kernel_accel = 0;
4495 device_param->kernel_loops = 0;
4496
4497 myfree (buf);
4498
4499 return NULL;
4500 }
4501
4502 static void *thread_calc (void *p)
4503 {
4504 hc_device_param_t *device_param = (hc_device_param_t *) p;
4505
4506 if (device_param->skipped) return NULL;
4507
4508 autotune (device_param);
4509
4510 const uint attack_mode = data.attack_mode;
4511 const uint attack_kern = data.attack_kern;
4512
4513 if (attack_mode == ATTACK_MODE_BF)
4514 {
4515 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4516 {
4517 const uint work = get_work (device_param, -1, true);
4518
4519 if (work == 0) break;
4520
4521 const u64 words_off = device_param->words_off;
4522 const u64 words_fin = words_off + work;
4523
4524 const uint pws_cnt = work;
4525
4526 device_param->pws_cnt = pws_cnt;
4527
4528 if (pws_cnt)
4529 {
4530 run_copy (device_param, pws_cnt);
4531
4532 run_cracker (device_param, pws_cnt);
4533
4534 device_param->pws_cnt = 0;
4535
4536 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4537 }
4538
4539 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4540
4541 if (data.devices_status == STATUS_CRACKED) break;
4542 if (data.devices_status == STATUS_ABORTED) break;
4543 if (data.devices_status == STATUS_QUIT) break;
4544 if (data.devices_status == STATUS_BYPASS) break;
4545
4546 if (data.benchmark == 1) break;
4547
4548 device_param->words_done = words_fin;
4549 }
4550 }
4551 else
4552 {
4553 const uint segment_size = data.segment_size;
4554
4555 char *dictfile = data.dictfile;
4556
4557 if (attack_mode == ATTACK_MODE_COMBI)
4558 {
4559 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4560 {
4561 dictfile = data.dictfile2;
4562 }
4563 }
4564
4565 FILE *fd = fopen (dictfile, "rb");
4566
4567 if (fd == NULL)
4568 {
4569 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4570
4571 return NULL;
4572 }
4573
4574 if (attack_mode == ATTACK_MODE_COMBI)
4575 {
4576 const uint combs_mode = data.combs_mode;
4577
4578 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4579 {
4580 const char *dictfilec = data.dictfile2;
4581
4582 FILE *combs_fp = fopen (dictfilec, "rb");
4583
4584 if (combs_fp == NULL)
4585 {
4586 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4587
4588 fclose (fd);
4589
4590 return NULL;
4591 }
4592
4593 device_param->combs_fp = combs_fp;
4594 }
4595 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4596 {
4597 const char *dictfilec = data.dictfile;
4598
4599 FILE *combs_fp = fopen (dictfilec, "rb");
4600
4601 if (combs_fp == NULL)
4602 {
4603 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4604
4605 fclose (fd);
4606
4607 return NULL;
4608 }
4609
4610 device_param->combs_fp = combs_fp;
4611 }
4612 }
4613
4614 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4615
4616 wl_data->buf = (char *) mymalloc (segment_size);
4617 wl_data->avail = segment_size;
4618 wl_data->incr = segment_size;
4619 wl_data->cnt = 0;
4620 wl_data->pos = 0;
4621
4622 u64 words_cur = 0;
4623
4624 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4625 {
4626 u64 words_off = 0;
4627 u64 words_fin = 0;
4628
4629 bool allow_div = true;
4630
4631 u64 max = -1;
4632
4633 while (max)
4634 {
4635 const uint work = get_work (device_param, max, allow_div);
4636
4637 allow_div = false;
4638
4639 if (work == 0) break;
4640
4641 words_off = device_param->words_off;
4642 words_fin = words_off + work;
4643
4644 char *line_buf;
4645 uint line_len;
4646
4647 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4648
4649 max = 0;
4650
4651 for ( ; words_cur < words_fin; words_cur++)
4652 {
4653 get_next_word (wl_data, fd, &line_buf, &line_len);
4654
4655 line_len = convert_from_hex (line_buf, line_len);
4656
4657 // post-process rule engine
4658
4659 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4660 {
4661 char rule_buf_out[BLOCK_SIZE] = { 0 };
4662
4663 int rule_len_out = -1;
4664
4665 if (line_len < BLOCK_SIZE)
4666 {
4667 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4668 }
4669
4670 if (rule_len_out < 0) continue;
4671
4672 line_buf = rule_buf_out;
4673 line_len = rule_len_out;
4674 }
4675
4676 if (attack_kern == ATTACK_KERN_STRAIGHT)
4677 {
4678 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4679 {
4680 max++;
4681
4682 hc_thread_mutex_lock (mux_counter);
4683
4684 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4685 {
4686 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4687 }
4688
4689 hc_thread_mutex_unlock (mux_counter);
4690
4691 continue;
4692 }
4693 }
4694 else if (attack_kern == ATTACK_KERN_COMBI)
4695 {
4696 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4697 // since we still need to combine the plains
4698
4699 if (line_len > data.pw_max)
4700 {
4701 max++;
4702
4703 hc_thread_mutex_lock (mux_counter);
4704
4705 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4706 {
4707 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4708 }
4709
4710 hc_thread_mutex_unlock (mux_counter);
4711
4712 continue;
4713 }
4714 }
4715
4716 pw_add (device_param, (u8 *) line_buf, line_len);
4717
4718 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4719
4720 if (data.devices_status == STATUS_CRACKED) break;
4721 if (data.devices_status == STATUS_ABORTED) break;
4722 if (data.devices_status == STATUS_QUIT) break;
4723 if (data.devices_status == STATUS_BYPASS) break;
4724 }
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 // flush
4743 //
4744
4745 const uint pws_cnt = device_param->pws_cnt;
4746
4747 if (pws_cnt)
4748 {
4749 run_copy (device_param, pws_cnt);
4750
4751 run_cracker (device_param, pws_cnt);
4752
4753 device_param->pws_cnt = 0;
4754
4755 if (attack_kern == ATTACK_KERN_STRAIGHT)
4756 {
4757 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4758 }
4759 else if (attack_kern == ATTACK_KERN_COMBI)
4760 {
4761 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4762 }
4763 }
4764
4765 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4766
4767 if (data.devices_status == STATUS_CRACKED) break;
4768 if (data.devices_status == STATUS_ABORTED) break;
4769 if (data.devices_status == STATUS_QUIT) break;
4770 if (data.devices_status == STATUS_BYPASS) break;
4771
4772 if (words_fin == 0) break;
4773
4774 device_param->words_done = words_fin;
4775 }
4776
4777 if (attack_mode == ATTACK_MODE_COMBI)
4778 {
4779 fclose (device_param->combs_fp);
4780 }
4781
4782 free (wl_data->buf);
4783 free (wl_data);
4784
4785 fclose (fd);
4786 }
4787
4788 device_param->kernel_accel = 0;
4789 device_param->kernel_loops = 0;
4790
4791 return NULL;
4792 }
4793
4794 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4795 {
4796 if (!device_param)
4797 {
4798 log_error ("ERROR: %s : Invalid argument", __func__);
4799
4800 exit (-1);
4801 }
4802
4803 salt_t *salt_buf = &data.salts_buf[salt_pos];
4804
4805 device_param->kernel_params_buf32[24] = salt_pos;
4806 device_param->kernel_params_buf32[27] = 1;
4807 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4808 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4809 device_param->kernel_params_buf32[30] = 0;
4810 device_param->kernel_params_buf32[31] = 1;
4811
4812 char *dictfile_old = data.dictfile;
4813
4814 const char *weak_hash_check = "weak-hash-check";
4815
4816 data.dictfile = (char *) weak_hash_check;
4817
4818 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4819
4820 data.kernel_rules_buf[0].cmds[0] = 0;
4821
4822 /**
4823 * run the kernel
4824 */
4825
4826 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4827 {
4828 run_kernel (KERN_RUN_1, device_param, 1, false);
4829 }
4830 else
4831 {
4832 run_kernel (KERN_RUN_1, device_param, 1, false);
4833
4834 uint loop_step = 16;
4835
4836 const uint iter = salt_buf->salt_iter;
4837
4838 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4839 {
4840 uint loop_left = iter - loop_pos;
4841
4842 loop_left = MIN (loop_left, loop_step);
4843
4844 device_param->kernel_params_buf32[25] = loop_pos;
4845 device_param->kernel_params_buf32[26] = loop_left;
4846
4847 run_kernel (KERN_RUN_2, device_param, 1, false);
4848 }
4849
4850 run_kernel (KERN_RUN_3, device_param, 1, false);
4851 }
4852
4853 /**
4854 * result
4855 */
4856
4857 check_cracked (device_param, salt_pos);
4858
4859 /**
4860 * cleanup
4861 */
4862
4863 device_param->kernel_params_buf32[24] = 0;
4864 device_param->kernel_params_buf32[25] = 0;
4865 device_param->kernel_params_buf32[26] = 0;
4866 device_param->kernel_params_buf32[27] = 0;
4867 device_param->kernel_params_buf32[28] = 0;
4868 device_param->kernel_params_buf32[29] = 0;
4869 device_param->kernel_params_buf32[30] = 0;
4870 device_param->kernel_params_buf32[31] = 0;
4871
4872 data.dictfile = dictfile_old;
4873
4874 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4875 }
4876
4877 // hlfmt hashcat
4878
4879 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4880 {
4881 if (data.username == 0)
4882 {
4883 *hashbuf_pos = line_buf;
4884 *hashbuf_len = line_len;
4885 }
4886 else
4887 {
4888 char *pos = line_buf;
4889 int len = line_len;
4890
4891 for (int i = 0; i < line_len; i++, pos++, len--)
4892 {
4893 if (line_buf[i] == data.separator)
4894 {
4895 pos++;
4896
4897 len--;
4898
4899 break;
4900 }
4901 }
4902
4903 *hashbuf_pos = pos;
4904 *hashbuf_len = len;
4905 }
4906 }
4907
4908 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4909 {
4910 char *pos = NULL;
4911 int len = 0;
4912
4913 int sep_cnt = 0;
4914
4915 for (int i = 0; i < line_len; i++)
4916 {
4917 if (line_buf[i] == data.separator)
4918 {
4919 sep_cnt++;
4920
4921 continue;
4922 }
4923
4924 if (sep_cnt == 0)
4925 {
4926 if (pos == NULL) pos = line_buf + i;
4927
4928 len++;
4929 }
4930 }
4931
4932 *userbuf_pos = pos;
4933 *userbuf_len = len;
4934 }
4935
4936 // hlfmt pwdump
4937
4938 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
4939 {
4940 int sep_cnt = 0;
4941
4942 int sep2_len = 0;
4943 int sep3_len = 0;
4944
4945 for (int i = 0; i < line_len; i++)
4946 {
4947 if (line_buf[i] == ':')
4948 {
4949 sep_cnt++;
4950
4951 continue;
4952 }
4953
4954 if (sep_cnt == 2) sep2_len++;
4955 if (sep_cnt == 3) sep3_len++;
4956 }
4957
4958 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4959
4960 return 0;
4961 }
4962
4963 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4964 {
4965 char *pos = NULL;
4966 int len = 0;
4967
4968 int sep_cnt = 0;
4969
4970 for (int i = 0; i < line_len; i++)
4971 {
4972 if (line_buf[i] == ':')
4973 {
4974 sep_cnt++;
4975
4976 continue;
4977 }
4978
4979 if (data.hash_mode == 1000)
4980 {
4981 if (sep_cnt == 3)
4982 {
4983 if (pos == NULL) pos = line_buf + i;
4984
4985 len++;
4986 }
4987 }
4988 else if (data.hash_mode == 3000)
4989 {
4990 if (sep_cnt == 2)
4991 {
4992 if (pos == NULL) pos = line_buf + i;
4993
4994 len++;
4995 }
4996 }
4997 }
4998
4999 *hashbuf_pos = pos;
5000 *hashbuf_len = len;
5001 }
5002
5003 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5004 {
5005 char *pos = NULL;
5006 int len = 0;
5007
5008 int sep_cnt = 0;
5009
5010 for (int i = 0; i < line_len; i++)
5011 {
5012 if (line_buf[i] == ':')
5013 {
5014 sep_cnt++;
5015
5016 continue;
5017 }
5018
5019 if (sep_cnt == 0)
5020 {
5021 if (pos == NULL) pos = line_buf + i;
5022
5023 len++;
5024 }
5025 }
5026
5027 *userbuf_pos = pos;
5028 *userbuf_len = len;
5029 }
5030
5031 // hlfmt passwd
5032
5033 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5034 {
5035 int sep_cnt = 0;
5036
5037 char sep5_first = 0;
5038 char sep6_first = 0;
5039
5040 for (int i = 0; i < line_len; i++)
5041 {
5042 if (line_buf[i] == ':')
5043 {
5044 sep_cnt++;
5045
5046 continue;
5047 }
5048
5049 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5050 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5051 }
5052
5053 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5054
5055 return 0;
5056 }
5057
5058 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5059 {
5060 char *pos = NULL;
5061 int len = 0;
5062
5063 int sep_cnt = 0;
5064
5065 for (int i = 0; i < line_len; i++)
5066 {
5067 if (line_buf[i] == ':')
5068 {
5069 sep_cnt++;
5070
5071 continue;
5072 }
5073
5074 if (sep_cnt == 1)
5075 {
5076 if (pos == NULL) pos = line_buf + i;
5077
5078 len++;
5079 }
5080 }
5081
5082 *hashbuf_pos = pos;
5083 *hashbuf_len = len;
5084 }
5085
5086 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5087 {
5088 char *pos = NULL;
5089 int len = 0;
5090
5091 int sep_cnt = 0;
5092
5093 for (int i = 0; i < line_len; i++)
5094 {
5095 if (line_buf[i] == ':')
5096 {
5097 sep_cnt++;
5098
5099 continue;
5100 }
5101
5102 if (sep_cnt == 0)
5103 {
5104 if (pos == NULL) pos = line_buf + i;
5105
5106 len++;
5107 }
5108 }
5109
5110 *userbuf_pos = pos;
5111 *userbuf_len = len;
5112 }
5113
5114 // hlfmt shadow
5115
5116 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5117 {
5118 int sep_cnt = 0;
5119
5120 for (int i = 0; i < line_len; i++)
5121 {
5122 if (line_buf[i] == ':') sep_cnt++;
5123 }
5124
5125 if (sep_cnt == 8) return 1;
5126
5127 return 0;
5128 }
5129
5130 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5131 {
5132 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5133 }
5134
5135 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5136 {
5137 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5138 }
5139
5140 // hlfmt main
5141
5142 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5143 {
5144 switch (hashfile_format)
5145 {
5146 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5147 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5148 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5149 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5150 }
5151 }
5152
5153 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5154 {
5155 switch (hashfile_format)
5156 {
5157 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5158 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5159 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5160 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5161 }
5162 }
5163
5164 char *strhlfmt (const uint hashfile_format)
5165 {
5166 switch (hashfile_format)
5167 {
5168 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5169 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5170 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5171 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5172 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5173 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5174 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5175 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5176 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5177 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5178 }
5179
5180 return ((char *) "Unknown");
5181 }
5182
5183 static uint hlfmt_detect (FILE *fp, uint max_check)
5184 {
5185 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5186
5187 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5188 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5189
5190 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5191
5192 uint num_check = 0;
5193
5194 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5195
5196 while (!feof (fp))
5197 {
5198 int line_len = fgetl (fp, line_buf);
5199
5200 if (line_len == 0) continue;
5201
5202 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5203 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5204 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5205
5206 if (num_check == max_check) break;
5207
5208 num_check++;
5209 }
5210
5211 myfree (line_buf);
5212
5213 uint hashlist_format = HLFMT_HASHCAT;
5214
5215 for (int i = 1; i < HLFMTS_CNT; i++)
5216 {
5217 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5218
5219 hashlist_format = i;
5220 }
5221
5222 free (formats_cnt);
5223
5224 return hashlist_format;
5225 }
5226
5227 /**
5228 * some further helper function
5229 */
5230
5231 // wrapper around mymalloc for ADL
5232
5233 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5234 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5235 {
5236 return mymalloc (iSize);
5237 }
5238 #endif
5239
5240 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)
5241 {
5242 u64 collisions = 0;
5243
5244 const uint dgst_pos0 = data.dgst_pos0;
5245 const uint dgst_pos1 = data.dgst_pos1;
5246 const uint dgst_pos2 = data.dgst_pos2;
5247 const uint dgst_pos3 = data.dgst_pos3;
5248
5249 memset (bitmap_a, 0, bitmap_size);
5250 memset (bitmap_b, 0, bitmap_size);
5251 memset (bitmap_c, 0, bitmap_size);
5252 memset (bitmap_d, 0, bitmap_size);
5253
5254 for (uint i = 0; i < digests_cnt; i++)
5255 {
5256 uint *digest_ptr = (uint *) digests_buf_ptr;
5257
5258 digests_buf_ptr += dgst_size;
5259
5260 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5261 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5262 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5263 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5264
5265 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5266 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5267 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5268 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5269
5270 if (bitmap_a[idx0] & val0) collisions++;
5271 if (bitmap_b[idx1] & val1) collisions++;
5272 if (bitmap_c[idx2] & val2) collisions++;
5273 if (bitmap_d[idx3] & val3) collisions++;
5274
5275 bitmap_a[idx0] |= val0;
5276 bitmap_b[idx1] |= val1;
5277 bitmap_c[idx2] |= val2;
5278 bitmap_d[idx3] |= val3;
5279
5280 if (collisions >= collisions_max) return 0x7fffffff;
5281 }
5282
5283 return collisions;
5284 }
5285
5286 /**
5287 * main
5288 */
5289
5290 int main (int argc, char **argv)
5291 {
5292 /**
5293 * To help users a bit
5294 */
5295
5296 char *compute = getenv ("COMPUTE");
5297
5298 if (compute)
5299 {
5300 static char display[100];
5301
5302 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5303
5304 putenv (display);
5305 }
5306 else
5307 {
5308 if (getenv ("DISPLAY") == NULL)
5309 putenv ((char *) "DISPLAY=:0");
5310 }
5311
5312 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5313 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5314
5315 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5316 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5317
5318 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5319 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5320
5321 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5322 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5323
5324 /**
5325 * Real init
5326 */
5327
5328 memset (&data, 0, sizeof (hc_global_data_t));
5329
5330 time_t proc_start;
5331
5332 time (&proc_start);
5333
5334 data.proc_start = proc_start;
5335
5336 int myargc = argc;
5337 char **myargv = argv;
5338
5339 hc_thread_mutex_init (mux_dispatcher);
5340 hc_thread_mutex_init (mux_counter);
5341 hc_thread_mutex_init (mux_display);
5342 hc_thread_mutex_init (mux_adl);
5343
5344 /**
5345 * commandline parameters
5346 */
5347
5348 uint usage = USAGE;
5349 uint version = VERSION;
5350 uint quiet = QUIET;
5351 uint benchmark = BENCHMARK;
5352 uint benchmark_repeats = BENCHMARK_REPEATS;
5353 uint show = SHOW;
5354 uint left = LEFT;
5355 uint username = USERNAME;
5356 uint remove = REMOVE;
5357 uint remove_timer = REMOVE_TIMER;
5358 u64 skip = SKIP;
5359 u64 limit = LIMIT;
5360 uint keyspace = KEYSPACE;
5361 uint potfile_disable = POTFILE_DISABLE;
5362 char *potfile_path = NULL;
5363 uint debug_mode = DEBUG_MODE;
5364 char *debug_file = NULL;
5365 char *induction_dir = NULL;
5366 char *outfile_check_dir = NULL;
5367 uint force = FORCE;
5368 uint runtime = RUNTIME;
5369 uint hash_mode = HASH_MODE;
5370 uint attack_mode = ATTACK_MODE;
5371 uint markov_disable = MARKOV_DISABLE;
5372 uint markov_classic = MARKOV_CLASSIC;
5373 uint markov_threshold = MARKOV_THRESHOLD;
5374 char *markov_hcstat = NULL;
5375 char *outfile = NULL;
5376 uint outfile_format = OUTFILE_FORMAT;
5377 uint outfile_autohex = OUTFILE_AUTOHEX;
5378 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5379 uint restore = RESTORE;
5380 uint restore_timer = RESTORE_TIMER;
5381 uint restore_disable = RESTORE_DISABLE;
5382 uint status = STATUS;
5383 uint status_timer = STATUS_TIMER;
5384 uint status_automat = STATUS_AUTOMAT;
5385 uint loopback = LOOPBACK;
5386 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5387 char *session = NULL;
5388 uint hex_charset = HEX_CHARSET;
5389 uint hex_salt = HEX_SALT;
5390 uint hex_wordlist = HEX_WORDLIST;
5391 uint rp_gen = RP_GEN;
5392 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5393 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5394 uint rp_gen_seed = RP_GEN_SEED;
5395 char *rule_buf_l = (char *) RULE_BUF_L;
5396 char *rule_buf_r = (char *) RULE_BUF_R;
5397 uint increment = INCREMENT;
5398 uint increment_min = INCREMENT_MIN;
5399 uint increment_max = INCREMENT_MAX;
5400 char *cpu_affinity = NULL;
5401 OCL_PTR *ocl = NULL;
5402 char *opencl_devices = NULL;
5403 char *opencl_platforms = NULL;
5404 char *opencl_device_types = NULL;
5405 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5406 char *truecrypt_keyfiles = NULL;
5407 uint workload_profile = WORKLOAD_PROFILE;
5408 uint kernel_accel = KERNEL_ACCEL;
5409 uint kernel_loops = KERNEL_LOOPS;
5410 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5411 #ifdef HAVE_HWMON
5412 uint gpu_temp_abort = GPU_TEMP_ABORT;
5413 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5414 #ifdef HAVE_ADL
5415 uint powertune_enable = POWERTUNE_ENABLE;
5416 #endif
5417 #endif
5418 uint logfile_disable = LOGFILE_DISABLE;
5419 uint segment_size = SEGMENT_SIZE;
5420 uint scrypt_tmto = SCRYPT_TMTO;
5421 char separator = SEPARATOR;
5422 uint bitmap_min = BITMAP_MIN;
5423 uint bitmap_max = BITMAP_MAX;
5424 char *custom_charset_1 = NULL;
5425 char *custom_charset_2 = NULL;
5426 char *custom_charset_3 = NULL;
5427 char *custom_charset_4 = NULL;
5428
5429 #define IDX_HELP 'h'
5430 #define IDX_VERSION 'V'
5431 #define IDX_VERSION_LOWER 'v'
5432 #define IDX_QUIET 0xff02
5433 #define IDX_SHOW 0xff03
5434 #define IDX_LEFT 0xff04
5435 #define IDX_REMOVE 0xff05
5436 #define IDX_REMOVE_TIMER 0xff37
5437 #define IDX_SKIP 's'
5438 #define IDX_LIMIT 'l'
5439 #define IDX_KEYSPACE 0xff35
5440 #define IDX_POTFILE_DISABLE 0xff06
5441 #define IDX_POTFILE_PATH 0xffe0
5442 #define IDX_DEBUG_MODE 0xff43
5443 #define IDX_DEBUG_FILE 0xff44
5444 #define IDX_INDUCTION_DIR 0xff46
5445 #define IDX_OUTFILE_CHECK_DIR 0xff47
5446 #define IDX_USERNAME 0xff07
5447 #define IDX_FORCE 0xff08
5448 #define IDX_RUNTIME 0xff09
5449 #define IDX_BENCHMARK 'b'
5450 #define IDX_BENCHMARK_REPEATS 0xff78
5451 #define IDX_HASH_MODE 'm'
5452 #define IDX_ATTACK_MODE 'a'
5453 #define IDX_RP_FILE 'r'
5454 #define IDX_RP_GEN 'g'
5455 #define IDX_RP_GEN_FUNC_MIN 0xff10
5456 #define IDX_RP_GEN_FUNC_MAX 0xff11
5457 #define IDX_RP_GEN_SEED 0xff34
5458 #define IDX_RULE_BUF_L 'j'
5459 #define IDX_RULE_BUF_R 'k'
5460 #define IDX_INCREMENT 'i'
5461 #define IDX_INCREMENT_MIN 0xff12
5462 #define IDX_INCREMENT_MAX 0xff13
5463 #define IDX_OUTFILE 'o'
5464 #define IDX_OUTFILE_FORMAT 0xff14
5465 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5466 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5467 #define IDX_RESTORE 0xff15
5468 #define IDX_RESTORE_DISABLE 0xff27
5469 #define IDX_STATUS 0xff17
5470 #define IDX_STATUS_TIMER 0xff18
5471 #define IDX_STATUS_AUTOMAT 0xff50
5472 #define IDX_LOOPBACK 0xff38
5473 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5474 #define IDX_SESSION 0xff19
5475 #define IDX_HEX_CHARSET 0xff20
5476 #define IDX_HEX_SALT 0xff21
5477 #define IDX_HEX_WORDLIST 0xff40
5478 #define IDX_MARKOV_DISABLE 0xff22
5479 #define IDX_MARKOV_CLASSIC 0xff23
5480 #define IDX_MARKOV_THRESHOLD 't'
5481 #define IDX_MARKOV_HCSTAT 0xff24
5482 #define IDX_CPU_AFFINITY 0xff25
5483 #define IDX_OPENCL_DEVICES 'd'
5484 #define IDX_OPENCL_PLATFORMS 0xff72
5485 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5486 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5487 #define IDX_WORKLOAD_PROFILE 'w'
5488 #define IDX_KERNEL_ACCEL 'n'
5489 #define IDX_KERNEL_LOOPS 'u'
5490 #define IDX_GPU_TEMP_DISABLE 0xff29
5491 #define IDX_GPU_TEMP_ABORT 0xff30
5492 #define IDX_GPU_TEMP_RETAIN 0xff31
5493 #define IDX_POWERTUNE_ENABLE 0xff41
5494 #define IDX_LOGFILE_DISABLE 0xff51
5495 #define IDX_TRUECRYPT_KEYFILES 0xff52
5496 #define IDX_SCRYPT_TMTO 0xff61
5497 #define IDX_SEGMENT_SIZE 'c'
5498 #define IDX_SEPARATOR 'p'
5499 #define IDX_BITMAP_MIN 0xff70
5500 #define IDX_BITMAP_MAX 0xff71
5501 #define IDX_CUSTOM_CHARSET_1 '1'
5502 #define IDX_CUSTOM_CHARSET_2 '2'
5503 #define IDX_CUSTOM_CHARSET_3 '3'
5504 #define IDX_CUSTOM_CHARSET_4 '4'
5505
5506 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5507
5508 struct option long_options[] =
5509 {
5510 {"help", no_argument, 0, IDX_HELP},
5511 {"version", no_argument, 0, IDX_VERSION},
5512 {"quiet", no_argument, 0, IDX_QUIET},
5513 {"show", no_argument, 0, IDX_SHOW},
5514 {"left", no_argument, 0, IDX_LEFT},
5515 {"username", no_argument, 0, IDX_USERNAME},
5516 {"remove", no_argument, 0, IDX_REMOVE},
5517 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5518 {"skip", required_argument, 0, IDX_SKIP},
5519 {"limit", required_argument, 0, IDX_LIMIT},
5520 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5521 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5522 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5523 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5524 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5525 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5526 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5527 {"force", no_argument, 0, IDX_FORCE},
5528 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5529 {"benchmark-repeats", required_argument, 0, IDX_BENCHMARK_REPEATS},
5530 {"restore", no_argument, 0, IDX_RESTORE},
5531 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5532 {"status", no_argument, 0, IDX_STATUS},
5533 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5534 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5535 {"loopback", no_argument, 0, IDX_LOOPBACK},
5536 {"weak-hash-threshold",
5537 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5538 {"session", required_argument, 0, IDX_SESSION},
5539 {"runtime", required_argument, 0, IDX_RUNTIME},
5540 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5541 {"generate-rules-func-min",
5542 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5543 {"generate-rules-func-max",
5544 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5545 {"generate-rules-seed",
5546 required_argument, 0, IDX_RP_GEN_SEED},
5547 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5548 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5549 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5550 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5551 {"rules-file", required_argument, 0, IDX_RP_FILE},
5552 {"outfile", required_argument, 0, IDX_OUTFILE},
5553 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5554 {"outfile-autohex-disable",
5555 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5556 {"outfile-check-timer",
5557 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5558 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5559 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5560 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5561 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5562 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5563 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5564 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5565 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5566 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5567 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5568 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5569 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5570 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5571 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5572 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5573 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5574 #ifdef HAVE_HWMON
5575 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5576 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5577 #ifdef HAVE_ADL
5578 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5579 #endif
5580 #endif // HAVE_HWMON
5581 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5582 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5583 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5584 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5585 // deprecated
5586 {"seperator", required_argument, 0, IDX_SEPARATOR},
5587 {"separator", required_argument, 0, IDX_SEPARATOR},
5588 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5589 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5590 {"increment", no_argument, 0, IDX_INCREMENT},
5591 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5592 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5593 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5594 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5595 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5596 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5597
5598 {0, 0, 0, 0}
5599 };
5600
5601 uint rp_files_cnt = 0;
5602
5603 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5604
5605 int option_index = 0;
5606 int c = -1;
5607
5608 optind = 1;
5609 optopt = 0;
5610
5611 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5612 {
5613 switch (c)
5614 {
5615 case IDX_HELP: usage = 1; break;
5616 case IDX_VERSION:
5617 case IDX_VERSION_LOWER: version = 1; break;
5618 case IDX_RESTORE: restore = 1; break;
5619 case IDX_SESSION: session = optarg; break;
5620 case IDX_SHOW: show = 1; break;
5621 case IDX_LEFT: left = 1; break;
5622 case '?': return (-1);
5623 }
5624 }
5625
5626 if (optopt != 0)
5627 {
5628 log_error ("ERROR: Invalid argument specified");
5629
5630 return (-1);
5631 }
5632
5633 /**
5634 * exit functions
5635 */
5636
5637 if (version)
5638 {
5639 log_info ("%s (%s)", VERSION_TAG, VERSION_SUM);
5640
5641 return (0);
5642 }
5643
5644 if (usage)
5645 {
5646 usage_big_print (PROGNAME);
5647
5648 return (0);
5649 }
5650
5651 /**
5652 * session needs to be set, always!
5653 */
5654
5655 if (session == NULL) session = (char *) PROGNAME;
5656
5657 /**
5658 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5659 */
5660
5661 char *exec_path = get_exec_path ();
5662
5663 #ifdef LINUX
5664
5665 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5666 char *resolved_exec_path = realpath (exec_path, NULL);
5667
5668 char *install_dir = get_install_dir (resolved_exec_path);
5669 char *profile_dir = NULL;
5670 char *session_dir = NULL;
5671 char *shared_dir = NULL;
5672
5673 if (strcmp (install_dir, resolved_install_folder) == 0)
5674 {
5675 struct passwd *pw = getpwuid (getuid ());
5676
5677 const char *homedir = pw->pw_dir;
5678
5679 profile_dir = get_profile_dir (homedir);
5680 session_dir = get_session_dir (profile_dir);
5681 shared_dir = strdup (SHARED_FOLDER);
5682
5683 mkdir (profile_dir, 0700);
5684 mkdir (session_dir, 0700);
5685 }
5686 else
5687 {
5688 profile_dir = install_dir;
5689 session_dir = install_dir;
5690 shared_dir = install_dir;
5691 }
5692
5693 myfree (resolved_install_folder);
5694 myfree (resolved_exec_path);
5695
5696 #else
5697
5698 char *install_dir = get_install_dir (exec_path);
5699 char *profile_dir = install_dir;
5700 char *session_dir = install_dir;
5701 char *shared_dir = install_dir;
5702
5703 #endif
5704
5705 data.install_dir = install_dir;
5706 data.profile_dir = profile_dir;
5707 data.session_dir = session_dir;
5708 data.shared_dir = shared_dir;
5709
5710 myfree (exec_path);
5711
5712 /**
5713 * kernel cache, we need to make sure folder exist
5714 */
5715
5716 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5717
5718 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5719
5720 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5721
5722 mkdir (kernels_folder, 0700);
5723
5724 myfree (kernels_folder);
5725
5726 /**
5727 * session
5728 */
5729
5730 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5731
5732 data.session = session;
5733
5734 char *eff_restore_file = (char *) mymalloc (session_size);
5735 char *new_restore_file = (char *) mymalloc (session_size);
5736
5737 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5738 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5739
5740 data.eff_restore_file = eff_restore_file;
5741 data.new_restore_file = new_restore_file;
5742
5743 if (((show == 1) || (left == 1)) && (restore == 1))
5744 {
5745 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5746 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5747
5748 return (-1);
5749 }
5750
5751 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5752 if ((show == 1) || (left == 1))
5753 {
5754 restore_disable = 1;
5755
5756 restore = 0;
5757 }
5758
5759 data.restore_disable = restore_disable;
5760
5761 restore_data_t *rd = init_restore (argc, argv);
5762
5763 data.rd = rd;
5764
5765 /**
5766 * restore file
5767 */
5768
5769 if (restore == 1)
5770 {
5771 read_restore (eff_restore_file, rd);
5772
5773 if (rd->version_bin < RESTORE_MIN)
5774 {
5775 log_error ("ERROR: Incompatible restore-file version");
5776
5777 return (-1);
5778 }
5779
5780 myargc = rd->argc;
5781 myargv = rd->argv;
5782
5783 #ifdef _POSIX
5784 rd->pid = getpid ();
5785 #elif _WIN
5786 rd->pid = GetCurrentProcessId ();
5787 #endif
5788 }
5789
5790 uint hash_mode_chgd = 0;
5791 uint runtime_chgd = 0;
5792 uint kernel_loops_chgd = 0;
5793 uint kernel_accel_chgd = 0;
5794 uint attack_mode_chgd = 0;
5795 uint outfile_format_chgd = 0;
5796 uint rp_gen_seed_chgd = 0;
5797 uint remove_timer_chgd = 0;
5798 uint increment_min_chgd = 0;
5799 uint increment_max_chgd = 0;
5800 uint workload_profile_chgd = 0;
5801 uint opencl_vector_width_chgd = 0;
5802
5803 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5804 uint gpu_temp_retain_chgd = 0;
5805 uint gpu_temp_abort_chgd = 0;
5806 #endif
5807
5808 optind = 1;
5809 optopt = 0;
5810 option_index = 0;
5811
5812 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5813 {
5814 switch (c)
5815 {
5816 //case IDX_HELP: usage = 1; break;
5817 //case IDX_VERSION: version = 1; break;
5818 //case IDX_RESTORE: restore = 1; break;
5819 case IDX_QUIET: quiet = 1; break;
5820 //case IDX_SHOW: show = 1; break;
5821 case IDX_SHOW: break;
5822 //case IDX_LEFT: left = 1; break;
5823 case IDX_LEFT: break;
5824 case IDX_USERNAME: username = 1; break;
5825 case IDX_REMOVE: remove = 1; break;
5826 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5827 remove_timer_chgd = 1; break;
5828 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5829 case IDX_POTFILE_PATH: potfile_path = optarg; break;
5830 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5831 case IDX_DEBUG_FILE: debug_file = optarg; break;
5832 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5833 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5834 case IDX_FORCE: force = 1; break;
5835 case IDX_SKIP: skip = atoll (optarg); break;
5836 case IDX_LIMIT: limit = atoll (optarg); break;
5837 case IDX_KEYSPACE: keyspace = 1; break;
5838 case IDX_BENCHMARK: benchmark = 1; break;
5839 case IDX_BENCHMARK_REPEATS: benchmark_repeats = atoi (optarg); break;
5840 case IDX_RESTORE: break;
5841 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5842 case IDX_STATUS: status = 1; break;
5843 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5844 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5845 case IDX_LOOPBACK: loopback = 1; break;
5846 case IDX_WEAK_HASH_THRESHOLD:
5847 weak_hash_threshold = atoi (optarg); break;
5848 //case IDX_SESSION: session = optarg; break;
5849 case IDX_SESSION: break;
5850 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5851 hash_mode_chgd = 1; break;
5852 case IDX_RUNTIME: runtime = atoi (optarg);
5853 runtime_chgd = 1; break;
5854 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5855 attack_mode_chgd = 1; break;
5856 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5857 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5858 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5859 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5860 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5861 rp_gen_seed_chgd = 1; break;
5862 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5863 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5864 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5865 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5866 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5867 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5868 case IDX_OUTFILE: outfile = optarg; break;
5869 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5870 outfile_format_chgd = 1; break;
5871 case IDX_OUTFILE_AUTOHEX_DISABLE:
5872 outfile_autohex = 0; break;
5873 case IDX_OUTFILE_CHECK_TIMER:
5874 outfile_check_timer = atoi (optarg); break;
5875 case IDX_HEX_CHARSET: hex_charset = 1; break;
5876 case IDX_HEX_SALT: hex_salt = 1; break;
5877 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5878 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5879 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5880 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5881 case IDX_OPENCL_DEVICE_TYPES:
5882 opencl_device_types = optarg; break;
5883 case IDX_OPENCL_VECTOR_WIDTH:
5884 opencl_vector_width = atoi (optarg);
5885 opencl_vector_width_chgd = 1; break;
5886 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
5887 workload_profile_chgd = 1; break;
5888 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5889 kernel_accel_chgd = 1; break;
5890 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5891 kernel_loops_chgd = 1; break;
5892 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5893 #ifdef HAVE_HWMON
5894 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5895 #ifdef HAVE_ADL
5896 gpu_temp_abort_chgd = 1;
5897 #endif
5898 break;
5899 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5900 #ifdef HAVE_ADL
5901 gpu_temp_retain_chgd = 1;
5902 #endif
5903 break;
5904 #ifdef HAVE_ADL
5905 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5906 #endif
5907 #endif // HAVE_HWMON
5908 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5909 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5910 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5911 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5912 case IDX_SEPARATOR: separator = optarg[0]; break;
5913 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5914 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5915 case IDX_INCREMENT: increment = 1; break;
5916 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5917 increment_min_chgd = 1; break;
5918 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5919 increment_max_chgd = 1; break;
5920 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5921 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5922 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5923 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5924
5925 default:
5926 log_error ("ERROR: Invalid argument specified");
5927 return (-1);
5928 }
5929 }
5930
5931 if (optopt != 0)
5932 {
5933 log_error ("ERROR: Invalid argument specified");
5934
5935 return (-1);
5936 }
5937
5938 /**
5939 * Inform user things getting started,
5940 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5941 * - we do not need to check algorithm_pos
5942 */
5943
5944 if (quiet == 0)
5945 {
5946 if (benchmark == 1)
5947 {
5948 log_info ("%s %s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5949
5950 log_info ("");
5951 }
5952 else if (restore == 1)
5953 {
5954 log_info ("%s %s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5955
5956 log_info ("");
5957 }
5958 else
5959 {
5960 log_info ("%s %s (%s) starting...", PROGNAME, VERSION_TAG, VERSION_SUM);
5961
5962 log_info ("");
5963 }
5964 }
5965
5966 /**
5967 * sanity check
5968 */
5969
5970 if (attack_mode > 7)
5971 {
5972 log_error ("ERROR: Invalid attack-mode specified");
5973
5974 return (-1);
5975 }
5976
5977 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5978 {
5979 log_error ("ERROR: Invalid runtime specified");
5980
5981 return (-1);
5982 }
5983
5984 if (hash_mode_chgd && hash_mode > 13400) // just added to remove compiler warnings for hash_mode_chgd
5985 {
5986 log_error ("ERROR: Invalid hash-type specified");
5987
5988 return (-1);
5989 }
5990
5991 // renamed hash modes
5992
5993 if (hash_mode_chgd)
5994 {
5995 int n = -1;
5996
5997 switch (hash_mode)
5998 {
5999 case 123: n = 124;
6000 break;
6001 }
6002
6003 if (n >= 0)
6004 {
6005 log_error ("Old -m specified, use -m %d instead", n);
6006
6007 return (-1);
6008 }
6009 }
6010
6011 if (username == 1)
6012 {
6013 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
6014 {
6015 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6016
6017 return (-1);
6018 }
6019 }
6020
6021 if (outfile_format > 16)
6022 {
6023 log_error ("ERROR: Invalid outfile-format specified");
6024
6025 return (-1);
6026 }
6027
6028 if (left == 1)
6029 {
6030 if (outfile_format_chgd == 1)
6031 {
6032 if (outfile_format > 1)
6033 {
6034 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6035
6036 return (-1);
6037 }
6038 }
6039 else
6040 {
6041 outfile_format = OUTFILE_FMT_HASH;
6042 }
6043 }
6044
6045 if (show == 1)
6046 {
6047 if (outfile_format_chgd == 1)
6048 {
6049 if ((outfile_format > 7) && (outfile_format < 16))
6050 {
6051 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6052
6053 return (-1);
6054 }
6055 }
6056 }
6057
6058 if (increment_min < INCREMENT_MIN)
6059 {
6060 log_error ("ERROR: Invalid increment-min specified");
6061
6062 return (-1);
6063 }
6064
6065 if (increment_max > INCREMENT_MAX)
6066 {
6067 log_error ("ERROR: Invalid increment-max specified");
6068
6069 return (-1);
6070 }
6071
6072 if (increment_min > increment_max)
6073 {
6074 log_error ("ERROR: Invalid increment-min specified");
6075
6076 return (-1);
6077 }
6078
6079 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6080 {
6081 log_error ("ERROR: increment is not allowed in attack-mode 0");
6082
6083 return (-1);
6084 }
6085
6086 if ((increment == 0) && (increment_min_chgd == 1))
6087 {
6088 log_error ("ERROR: increment-min is only supported together with increment switch");
6089
6090 return (-1);
6091 }
6092
6093 if ((increment == 0) && (increment_max_chgd == 1))
6094 {
6095 log_error ("ERROR: increment-max is only supported together with increment switch");
6096
6097 return (-1);
6098 }
6099
6100 if (rp_files_cnt && rp_gen)
6101 {
6102 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6103
6104 return (-1);
6105 }
6106
6107 if (rp_files_cnt || rp_gen)
6108 {
6109 if (attack_mode != ATTACK_MODE_STRAIGHT)
6110 {
6111 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6112
6113 return (-1);
6114 }
6115 }
6116
6117 if (rp_gen_func_min > rp_gen_func_max)
6118 {
6119 log_error ("ERROR: Invalid rp-gen-func-min specified");
6120
6121 return (-1);
6122 }
6123
6124 if (kernel_accel_chgd == 1)
6125 {
6126 if (kernel_accel < 1)
6127 {
6128 log_error ("ERROR: Invalid kernel-accel specified");
6129
6130 return (-1);
6131 }
6132
6133 if (kernel_accel > 1024)
6134 {
6135 log_error ("ERROR: Invalid kernel-accel specified");
6136
6137 return (-1);
6138 }
6139 }
6140
6141 if (kernel_loops_chgd == 1)
6142 {
6143 if (kernel_loops < 1)
6144 {
6145 log_error ("ERROR: Invalid kernel-loops specified");
6146
6147 return (-1);
6148 }
6149
6150 if (kernel_loops > 1024)
6151 {
6152 log_error ("ERROR: Invalid kernel-loops specified");
6153
6154 return (-1);
6155 }
6156 }
6157
6158 if ((workload_profile < 1) || (workload_profile > 3))
6159 {
6160 log_error ("ERROR: workload-profile %i not available", workload_profile);
6161
6162 return (-1);
6163 }
6164
6165 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6166 {
6167 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6168
6169 return (-1);
6170 }
6171
6172 if (show == 1 || left == 1)
6173 {
6174 attack_mode = ATTACK_MODE_NONE;
6175
6176 if (remove == 1)
6177 {
6178 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6179
6180 return (-1);
6181 }
6182
6183 if (potfile_disable == 1)
6184 {
6185 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6186
6187 return (-1);
6188 }
6189 }
6190
6191 uint attack_kern = ATTACK_KERN_NONE;
6192
6193 switch (attack_mode)
6194 {
6195 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6196 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6197 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6198 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6199 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6200 }
6201
6202 if (benchmark == 0)
6203 {
6204 if (keyspace == 1)
6205 {
6206 int num_additional_params = 1;
6207
6208 if (attack_kern == ATTACK_KERN_COMBI)
6209 {
6210 num_additional_params = 2;
6211 }
6212
6213 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6214
6215 if (keyspace_wordlist_specified == 0) optind--;
6216 }
6217
6218 if (attack_kern == ATTACK_KERN_NONE)
6219 {
6220 if ((optind + 1) != myargc)
6221 {
6222 usage_mini_print (myargv[0]);
6223
6224 return (-1);
6225 }
6226 }
6227 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6228 {
6229 if ((optind + 1) > myargc)
6230 {
6231 usage_mini_print (myargv[0]);
6232
6233 return (-1);
6234 }
6235 }
6236 else if (attack_kern == ATTACK_KERN_COMBI)
6237 {
6238 if ((optind + 3) != myargc)
6239 {
6240 usage_mini_print (myargv[0]);
6241
6242 return (-1);
6243 }
6244 }
6245 else if (attack_kern == ATTACK_KERN_BF)
6246 {
6247 if ((optind + 1) > myargc)
6248 {
6249 usage_mini_print (myargv[0]);
6250
6251 return (-1);
6252 }
6253 }
6254 else
6255 {
6256 usage_mini_print (myargv[0]);
6257
6258 return (-1);
6259 }
6260 }
6261 else
6262 {
6263 if (myargv[optind] != 0)
6264 {
6265 log_error ("ERROR: Invalid argument for benchmark mode specified");
6266
6267 return (-1);
6268 }
6269
6270 if (attack_mode_chgd == 1)
6271 {
6272 if (attack_mode != ATTACK_MODE_BF)
6273 {
6274 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6275
6276 return (-1);
6277 }
6278 }
6279 }
6280
6281 if (skip != 0 && limit != 0)
6282 {
6283 limit += skip;
6284 }
6285
6286 if (keyspace == 1)
6287 {
6288 if (show == 1)
6289 {
6290 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6291
6292 return (-1);
6293 }
6294 else if (left == 1)
6295 {
6296 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6297
6298 return (-1);
6299 }
6300
6301 potfile_disable = 1;
6302
6303 restore_disable = 1;
6304
6305 restore = 0;
6306
6307 weak_hash_threshold = 0;
6308
6309 quiet = 1;
6310 }
6311
6312 if (remove_timer_chgd == 1)
6313 {
6314 if (remove == 0)
6315 {
6316 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6317
6318 return (-1);
6319 }
6320
6321 if (remove_timer < 1)
6322 {
6323 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6324
6325 return (-1);
6326 }
6327 }
6328
6329 if (loopback == 1)
6330 {
6331 if (attack_mode == ATTACK_MODE_BF)
6332 {
6333 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
6334
6335 return (-1);
6336 }
6337 else if (attack_mode == ATTACK_MODE_STRAIGHT)
6338 {
6339 if ((rp_files_cnt == 0) && (rp_gen == 0))
6340 {
6341 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6342
6343 return (-1);
6344 }
6345 }
6346 }
6347
6348 if (debug_mode > 0)
6349 {
6350 if (attack_mode != ATTACK_MODE_STRAIGHT)
6351 {
6352 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6353
6354 return (-1);
6355 }
6356
6357 if ((rp_files_cnt == 0) && (rp_gen == 0))
6358 {
6359 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6360
6361 return (-1);
6362 }
6363 }
6364
6365 if (debug_mode > 4)
6366 {
6367 log_error ("ERROR: Invalid debug-mode specified");
6368
6369 return (-1);
6370 }
6371
6372 if (debug_file != NULL)
6373 {
6374 if (debug_mode < 1)
6375 {
6376 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6377
6378 return (-1);
6379 }
6380 }
6381
6382 if (induction_dir != NULL)
6383 {
6384 if (attack_mode == ATTACK_MODE_BF)
6385 {
6386 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6387
6388 return (-1);
6389 }
6390 }
6391
6392 if (attack_mode != ATTACK_MODE_STRAIGHT)
6393 {
6394 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6395 {
6396 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6397
6398 return (-1);
6399 }
6400
6401 weak_hash_threshold = 0;
6402 }
6403
6404 /**
6405 * induction directory
6406 */
6407
6408 char *induction_directory = NULL;
6409
6410 if (attack_mode != ATTACK_MODE_BF)
6411 {
6412 if (induction_dir == NULL)
6413 {
6414 induction_directory = (char *) mymalloc (session_size);
6415
6416 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6417
6418 // create induction folder if it does not already exist
6419
6420 if (keyspace == 0)
6421 {
6422 if (rmdir (induction_directory) == -1)
6423 {
6424 if (errno == ENOENT)
6425 {
6426 // good, we can ignore
6427 }
6428 else if (errno == ENOTEMPTY)
6429 {
6430 char *induction_directory_mv = (char *) mymalloc (session_size);
6431
6432 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6433
6434 if (rename (induction_directory, induction_directory_mv) != 0)
6435 {
6436 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6437
6438 return (-1);
6439 }
6440 }
6441 else
6442 {
6443 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6444
6445 return (-1);
6446 }
6447 }
6448
6449 if (mkdir (induction_directory, 0700) == -1)
6450 {
6451 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6452
6453 return (-1);
6454 }
6455 }
6456 }
6457 else
6458 {
6459 induction_directory = induction_dir;
6460 }
6461 }
6462
6463 data.induction_directory = induction_directory;
6464
6465 /**
6466 * loopback
6467 */
6468
6469 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6470
6471 char *loopback_file = (char *) mymalloc (loopback_size);
6472
6473 /**
6474 * tuning db
6475 */
6476
6477 char tuning_db_file[256] = { 0 };
6478
6479 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6480
6481 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6482
6483 /**
6484 * outfile-check directory
6485 */
6486
6487 char *outfile_check_directory = NULL;
6488
6489 if (outfile_check_dir == NULL)
6490 {
6491 outfile_check_directory = (char *) mymalloc (session_size);
6492
6493 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6494 }
6495 else
6496 {
6497 outfile_check_directory = outfile_check_dir;
6498 }
6499
6500 data.outfile_check_directory = outfile_check_directory;
6501
6502 if (keyspace == 0)
6503 {
6504 struct stat outfile_check_stat;
6505
6506 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6507 {
6508 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6509
6510 if (is_dir == 0)
6511 {
6512 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6513
6514 return (-1);
6515 }
6516 }
6517 else if (outfile_check_dir == NULL)
6518 {
6519 if (mkdir (outfile_check_directory, 0700) == -1)
6520 {
6521 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6522
6523 return (-1);
6524 }
6525 }
6526 }
6527
6528 /**
6529 * special other stuff
6530 */
6531
6532 if (hash_mode == 9710)
6533 {
6534 outfile_format = 5;
6535 outfile_format_chgd = 1;
6536 }
6537
6538 if (hash_mode == 9810)
6539 {
6540 outfile_format = 5;
6541 outfile_format_chgd = 1;
6542 }
6543
6544 if (hash_mode == 10410)
6545 {
6546 outfile_format = 5;
6547 outfile_format_chgd = 1;
6548 }
6549
6550 /**
6551 * store stuff
6552 */
6553
6554 data.hash_mode = hash_mode;
6555 data.restore = restore;
6556 data.restore_timer = restore_timer;
6557 data.restore_disable = restore_disable;
6558 data.status = status;
6559 data.status_timer = status_timer;
6560 data.status_automat = status_automat;
6561 data.loopback = loopback;
6562 data.runtime = runtime;
6563 data.remove = remove;
6564 data.remove_timer = remove_timer;
6565 data.debug_mode = debug_mode;
6566 data.debug_file = debug_file;
6567 data.username = username;
6568 data.quiet = quiet;
6569 data.outfile = outfile;
6570 data.outfile_format = outfile_format;
6571 data.outfile_autohex = outfile_autohex;
6572 data.hex_charset = hex_charset;
6573 data.hex_salt = hex_salt;
6574 data.hex_wordlist = hex_wordlist;
6575 data.separator = separator;
6576 data.rp_files = rp_files;
6577 data.rp_files_cnt = rp_files_cnt;
6578 data.rp_gen = rp_gen;
6579 data.rp_gen_seed = rp_gen_seed;
6580 data.force = force;
6581 data.benchmark = benchmark;
6582 data.benchmark_repeats = benchmark_repeats;
6583 data.skip = skip;
6584 data.limit = limit;
6585 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6586 data.powertune_enable = powertune_enable;
6587 #endif
6588 data.logfile_disable = logfile_disable;
6589 data.truecrypt_keyfiles = truecrypt_keyfiles;
6590 data.scrypt_tmto = scrypt_tmto;
6591 data.workload_profile = workload_profile;
6592
6593 /**
6594 * cpu affinity
6595 */
6596
6597 if (cpu_affinity)
6598 {
6599 set_cpu_affinity (cpu_affinity);
6600 }
6601
6602 if (rp_gen_seed_chgd == 0)
6603 {
6604 srand (proc_start);
6605 }
6606 else
6607 {
6608 srand (rp_gen_seed);
6609 }
6610
6611 /**
6612 * logfile init
6613 */
6614
6615 if (logfile_disable == 0)
6616 {
6617 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6618
6619 char *logfile = (char *) mymalloc (logfile_size);
6620
6621 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6622
6623 data.logfile = logfile;
6624
6625 char *topid = logfile_generate_topid ();
6626
6627 data.topid = topid;
6628 }
6629
6630 // logfile_append() checks for logfile_disable internally to make it easier from here
6631
6632 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6633 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6634 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6635 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6636 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6637 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6638 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6639 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6640 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6641 #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));
6642
6643 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6644 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6645 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6646 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6647 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6648 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6649 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6650 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6651
6652 logfile_top_msg ("START");
6653
6654 logfile_top_uint (attack_mode);
6655 logfile_top_uint (attack_kern);
6656 logfile_top_uint (benchmark);
6657 logfile_top_uint (benchmark_repeats);
6658 logfile_top_uint (bitmap_min);
6659 logfile_top_uint (bitmap_max);
6660 logfile_top_uint (debug_mode);
6661 logfile_top_uint (force);
6662 logfile_top_uint (kernel_accel);
6663 logfile_top_uint (kernel_loops);
6664 logfile_top_uint (gpu_temp_disable);
6665 #ifdef HAVE_HWMON
6666 logfile_top_uint (gpu_temp_abort);
6667 logfile_top_uint (gpu_temp_retain);
6668 #endif
6669 logfile_top_uint (hash_mode);
6670 logfile_top_uint (hex_charset);
6671 logfile_top_uint (hex_salt);
6672 logfile_top_uint (hex_wordlist);
6673 logfile_top_uint (increment);
6674 logfile_top_uint (increment_max);
6675 logfile_top_uint (increment_min);
6676 logfile_top_uint (keyspace);
6677 logfile_top_uint (left);
6678 logfile_top_uint (logfile_disable);
6679 logfile_top_uint (loopback);
6680 logfile_top_uint (markov_classic);
6681 logfile_top_uint (markov_disable);
6682 logfile_top_uint (markov_threshold);
6683 logfile_top_uint (outfile_autohex);
6684 logfile_top_uint (outfile_check_timer);
6685 logfile_top_uint (outfile_format);
6686 logfile_top_uint (potfile_disable);
6687 logfile_top_string (potfile_path);
6688 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6689 logfile_top_uint (powertune_enable);
6690 #endif
6691 logfile_top_uint (scrypt_tmto);
6692 logfile_top_uint (quiet);
6693 logfile_top_uint (remove);
6694 logfile_top_uint (remove_timer);
6695 logfile_top_uint (restore);
6696 logfile_top_uint (restore_disable);
6697 logfile_top_uint (restore_timer);
6698 logfile_top_uint (rp_gen);
6699 logfile_top_uint (rp_gen_func_max);
6700 logfile_top_uint (rp_gen_func_min);
6701 logfile_top_uint (rp_gen_seed);
6702 logfile_top_uint (runtime);
6703 logfile_top_uint (segment_size);
6704 logfile_top_uint (show);
6705 logfile_top_uint (status);
6706 logfile_top_uint (status_automat);
6707 logfile_top_uint (status_timer);
6708 logfile_top_uint (usage);
6709 logfile_top_uint (username);
6710 logfile_top_uint (version);
6711 logfile_top_uint (weak_hash_threshold);
6712 logfile_top_uint (workload_profile);
6713 logfile_top_uint64 (limit);
6714 logfile_top_uint64 (skip);
6715 logfile_top_char (separator);
6716 logfile_top_string (cpu_affinity);
6717 logfile_top_string (custom_charset_1);
6718 logfile_top_string (custom_charset_2);
6719 logfile_top_string (custom_charset_3);
6720 logfile_top_string (custom_charset_4);
6721 logfile_top_string (debug_file);
6722 logfile_top_string (opencl_devices);
6723 logfile_top_string (opencl_platforms);
6724 logfile_top_string (opencl_device_types);
6725 logfile_top_uint (opencl_vector_width);
6726 logfile_top_string (induction_dir);
6727 logfile_top_string (markov_hcstat);
6728 logfile_top_string (outfile);
6729 logfile_top_string (outfile_check_dir);
6730 logfile_top_string (rule_buf_l);
6731 logfile_top_string (rule_buf_r);
6732 logfile_top_string (session);
6733 logfile_top_string (truecrypt_keyfiles);
6734
6735 /**
6736 * Init OpenCL library loader
6737 */
6738
6739 if (keyspace == 0)
6740 {
6741 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6742
6743 ocl_init (ocl);
6744
6745 data.ocl = ocl;
6746 }
6747
6748 /**
6749 * OpenCL platform selection
6750 */
6751
6752 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6753
6754 /**
6755 * OpenCL device selection
6756 */
6757
6758 u32 devices_filter = setup_devices_filter (opencl_devices);
6759
6760 /**
6761 * OpenCL device type selection
6762 */
6763
6764 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6765
6766 /**
6767 * benchmark
6768 */
6769
6770 if (benchmark == 1)
6771 {
6772 /**
6773 * disable useless stuff for benchmark
6774 */
6775
6776 status_timer = 0;
6777 restore_timer = 0;
6778 restore_disable = 1;
6779 potfile_disable = 1;
6780 weak_hash_threshold = 0;
6781 gpu_temp_disable = 1;
6782
6783 data.status_timer = status_timer;
6784 data.restore_timer = restore_timer;
6785 data.restore_disable = restore_disable;
6786
6787 /**
6788 * force attack mode to be bruteforce
6789 */
6790
6791 attack_mode = ATTACK_MODE_BF;
6792 attack_kern = ATTACK_KERN_BF;
6793
6794 if (workload_profile_chgd == 0)
6795 {
6796 workload_profile = 3;
6797
6798 data.workload_profile = workload_profile;
6799 }
6800 }
6801
6802 /**
6803 * config
6804 */
6805
6806 uint hash_type = 0;
6807 uint salt_type = 0;
6808 uint attack_exec = 0;
6809 uint opts_type = 0;
6810 uint kern_type = 0;
6811 uint dgst_size = 0;
6812 uint esalt_size = 0;
6813 uint opti_type = 0;
6814 uint dgst_pos0 = -1;
6815 uint dgst_pos1 = -1;
6816 uint dgst_pos2 = -1;
6817 uint dgst_pos3 = -1;
6818
6819 int (*parse_func) (char *, uint, hash_t *);
6820 int (*sort_by_digest) (const void *, const void *);
6821
6822 uint algorithm_pos = 0;
6823 uint algorithm_max = 1;
6824
6825 uint *algorithms = default_benchmark_algorithms;
6826
6827 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6828
6829 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6830 {
6831 /*
6832 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6833 * the following algos are skipped entirely
6834 */
6835
6836 if (algorithm_pos > 0)
6837 {
6838 local_free (rd);
6839
6840 rd = init_restore (argc, argv);
6841
6842 data.rd = rd;
6843 }
6844
6845 /**
6846 * update hash_mode in case of multihash benchmark
6847 */
6848
6849 if (benchmark == 1)
6850 {
6851 if (hash_mode_chgd == 0)
6852 {
6853 hash_mode = algorithms[algorithm_pos];
6854
6855 data.hash_mode = hash_mode;
6856 }
6857
6858 quiet = 1;
6859
6860 data.quiet = quiet;
6861 }
6862
6863 switch (hash_mode)
6864 {
6865 case 0: hash_type = HASH_TYPE_MD5;
6866 salt_type = SALT_TYPE_NONE;
6867 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6868 opts_type = OPTS_TYPE_PT_GENERATE_LE
6869 | OPTS_TYPE_PT_ADD80
6870 | OPTS_TYPE_PT_ADDBITS14;
6871 kern_type = KERN_TYPE_MD5;
6872 dgst_size = DGST_SIZE_4_4;
6873 parse_func = md5_parse_hash;
6874 sort_by_digest = sort_by_digest_4_4;
6875 opti_type = OPTI_TYPE_ZERO_BYTE
6876 | OPTI_TYPE_PRECOMPUTE_INIT
6877 | OPTI_TYPE_PRECOMPUTE_MERKLE
6878 | OPTI_TYPE_MEET_IN_MIDDLE
6879 | OPTI_TYPE_EARLY_SKIP
6880 | OPTI_TYPE_NOT_ITERATED
6881 | OPTI_TYPE_NOT_SALTED
6882 | OPTI_TYPE_RAW_HASH;
6883 dgst_pos0 = 0;
6884 dgst_pos1 = 3;
6885 dgst_pos2 = 2;
6886 dgst_pos3 = 1;
6887 break;
6888
6889 case 10: hash_type = HASH_TYPE_MD5;
6890 salt_type = SALT_TYPE_INTERN;
6891 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6892 opts_type = OPTS_TYPE_PT_GENERATE_LE
6893 | OPTS_TYPE_ST_ADD80
6894 | OPTS_TYPE_ST_ADDBITS14;
6895 kern_type = KERN_TYPE_MD5_PWSLT;
6896 dgst_size = DGST_SIZE_4_4;
6897 parse_func = md5s_parse_hash;
6898 sort_by_digest = sort_by_digest_4_4;
6899 opti_type = OPTI_TYPE_ZERO_BYTE
6900 | OPTI_TYPE_PRECOMPUTE_INIT
6901 | OPTI_TYPE_PRECOMPUTE_MERKLE
6902 | OPTI_TYPE_MEET_IN_MIDDLE
6903 | OPTI_TYPE_EARLY_SKIP
6904 | OPTI_TYPE_NOT_ITERATED
6905 | OPTI_TYPE_APPENDED_SALT
6906 | OPTI_TYPE_RAW_HASH;
6907 dgst_pos0 = 0;
6908 dgst_pos1 = 3;
6909 dgst_pos2 = 2;
6910 dgst_pos3 = 1;
6911 break;
6912
6913 case 11: hash_type = HASH_TYPE_MD5;
6914 salt_type = SALT_TYPE_INTERN;
6915 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6916 opts_type = OPTS_TYPE_PT_GENERATE_LE
6917 | OPTS_TYPE_ST_ADD80
6918 | OPTS_TYPE_ST_ADDBITS14;
6919 kern_type = KERN_TYPE_MD5_PWSLT;
6920 dgst_size = DGST_SIZE_4_4;
6921 parse_func = joomla_parse_hash;
6922 sort_by_digest = sort_by_digest_4_4;
6923 opti_type = OPTI_TYPE_ZERO_BYTE
6924 | OPTI_TYPE_PRECOMPUTE_INIT
6925 | OPTI_TYPE_PRECOMPUTE_MERKLE
6926 | OPTI_TYPE_MEET_IN_MIDDLE
6927 | OPTI_TYPE_EARLY_SKIP
6928 | OPTI_TYPE_NOT_ITERATED
6929 | OPTI_TYPE_APPENDED_SALT
6930 | OPTI_TYPE_RAW_HASH;
6931 dgst_pos0 = 0;
6932 dgst_pos1 = 3;
6933 dgst_pos2 = 2;
6934 dgst_pos3 = 1;
6935 break;
6936
6937 case 12: hash_type = HASH_TYPE_MD5;
6938 salt_type = SALT_TYPE_INTERN;
6939 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6940 opts_type = OPTS_TYPE_PT_GENERATE_LE
6941 | OPTS_TYPE_ST_ADD80
6942 | OPTS_TYPE_ST_ADDBITS14;
6943 kern_type = KERN_TYPE_MD5_PWSLT;
6944 dgst_size = DGST_SIZE_4_4;
6945 parse_func = postgresql_parse_hash;
6946 sort_by_digest = sort_by_digest_4_4;
6947 opti_type = OPTI_TYPE_ZERO_BYTE
6948 | OPTI_TYPE_PRECOMPUTE_INIT
6949 | OPTI_TYPE_PRECOMPUTE_MERKLE
6950 | OPTI_TYPE_MEET_IN_MIDDLE
6951 | OPTI_TYPE_EARLY_SKIP
6952 | OPTI_TYPE_NOT_ITERATED
6953 | OPTI_TYPE_APPENDED_SALT
6954 | OPTI_TYPE_RAW_HASH;
6955 dgst_pos0 = 0;
6956 dgst_pos1 = 3;
6957 dgst_pos2 = 2;
6958 dgst_pos3 = 1;
6959 break;
6960
6961 case 20: hash_type = HASH_TYPE_MD5;
6962 salt_type = SALT_TYPE_INTERN;
6963 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6964 opts_type = OPTS_TYPE_PT_GENERATE_LE
6965 | OPTS_TYPE_PT_ADD80
6966 | OPTS_TYPE_PT_ADDBITS14;
6967 kern_type = KERN_TYPE_MD5_SLTPW;
6968 dgst_size = DGST_SIZE_4_4;
6969 parse_func = md5s_parse_hash;
6970 sort_by_digest = sort_by_digest_4_4;
6971 opti_type = OPTI_TYPE_ZERO_BYTE
6972 | OPTI_TYPE_PRECOMPUTE_INIT
6973 | OPTI_TYPE_PRECOMPUTE_MERKLE
6974 | OPTI_TYPE_EARLY_SKIP
6975 | OPTI_TYPE_NOT_ITERATED
6976 | OPTI_TYPE_PREPENDED_SALT
6977 | OPTI_TYPE_RAW_HASH;
6978 dgst_pos0 = 0;
6979 dgst_pos1 = 3;
6980 dgst_pos2 = 2;
6981 dgst_pos3 = 1;
6982 break;
6983
6984 case 21: hash_type = HASH_TYPE_MD5;
6985 salt_type = SALT_TYPE_INTERN;
6986 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6987 opts_type = OPTS_TYPE_PT_GENERATE_LE
6988 | OPTS_TYPE_PT_ADD80
6989 | OPTS_TYPE_PT_ADDBITS14;
6990 kern_type = KERN_TYPE_MD5_SLTPW;
6991 dgst_size = DGST_SIZE_4_4;
6992 parse_func = osc_parse_hash;
6993 sort_by_digest = sort_by_digest_4_4;
6994 opti_type = OPTI_TYPE_ZERO_BYTE
6995 | OPTI_TYPE_PRECOMPUTE_INIT
6996 | OPTI_TYPE_PRECOMPUTE_MERKLE
6997 | OPTI_TYPE_EARLY_SKIP
6998 | OPTI_TYPE_NOT_ITERATED
6999 | OPTI_TYPE_PREPENDED_SALT
7000 | OPTI_TYPE_RAW_HASH;
7001 dgst_pos0 = 0;
7002 dgst_pos1 = 3;
7003 dgst_pos2 = 2;
7004 dgst_pos3 = 1;
7005 break;
7006
7007 case 22: hash_type = HASH_TYPE_MD5;
7008 salt_type = SALT_TYPE_EMBEDDED;
7009 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7010 opts_type = OPTS_TYPE_PT_GENERATE_LE
7011 | OPTS_TYPE_PT_ADD80
7012 | OPTS_TYPE_PT_ADDBITS14;
7013 kern_type = KERN_TYPE_MD5_SLTPW;
7014 dgst_size = DGST_SIZE_4_4;
7015 parse_func = netscreen_parse_hash;
7016 sort_by_digest = sort_by_digest_4_4;
7017 opti_type = OPTI_TYPE_ZERO_BYTE
7018 | OPTI_TYPE_PRECOMPUTE_INIT
7019 | OPTI_TYPE_PRECOMPUTE_MERKLE
7020 | OPTI_TYPE_EARLY_SKIP
7021 | OPTI_TYPE_NOT_ITERATED
7022 | OPTI_TYPE_PREPENDED_SALT
7023 | OPTI_TYPE_RAW_HASH;
7024 dgst_pos0 = 0;
7025 dgst_pos1 = 3;
7026 dgst_pos2 = 2;
7027 dgst_pos3 = 1;
7028 break;
7029
7030 case 23: hash_type = HASH_TYPE_MD5;
7031 salt_type = SALT_TYPE_EMBEDDED;
7032 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7033 opts_type = OPTS_TYPE_PT_GENERATE_LE
7034 | OPTS_TYPE_PT_ADD80
7035 | OPTS_TYPE_PT_ADDBITS14;
7036 kern_type = KERN_TYPE_MD5_SLTPW;
7037 dgst_size = DGST_SIZE_4_4;
7038 parse_func = skype_parse_hash;
7039 sort_by_digest = sort_by_digest_4_4;
7040 opti_type = OPTI_TYPE_ZERO_BYTE
7041 | OPTI_TYPE_PRECOMPUTE_INIT
7042 | OPTI_TYPE_PRECOMPUTE_MERKLE
7043 | OPTI_TYPE_EARLY_SKIP
7044 | OPTI_TYPE_NOT_ITERATED
7045 | OPTI_TYPE_PREPENDED_SALT
7046 | OPTI_TYPE_RAW_HASH;
7047 dgst_pos0 = 0;
7048 dgst_pos1 = 3;
7049 dgst_pos2 = 2;
7050 dgst_pos3 = 1;
7051 break;
7052
7053 case 30: hash_type = HASH_TYPE_MD5;
7054 salt_type = SALT_TYPE_INTERN;
7055 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7056 opts_type = OPTS_TYPE_PT_GENERATE_LE
7057 | OPTS_TYPE_PT_UNICODE
7058 | OPTS_TYPE_ST_ADD80
7059 | OPTS_TYPE_ST_ADDBITS14;
7060 kern_type = KERN_TYPE_MD5_PWUSLT;
7061 dgst_size = DGST_SIZE_4_4;
7062 parse_func = md5s_parse_hash;
7063 sort_by_digest = sort_by_digest_4_4;
7064 opti_type = OPTI_TYPE_ZERO_BYTE
7065 | OPTI_TYPE_PRECOMPUTE_INIT
7066 | OPTI_TYPE_PRECOMPUTE_MERKLE
7067 | OPTI_TYPE_MEET_IN_MIDDLE
7068 | OPTI_TYPE_EARLY_SKIP
7069 | OPTI_TYPE_NOT_ITERATED
7070 | OPTI_TYPE_APPENDED_SALT
7071 | OPTI_TYPE_RAW_HASH;
7072 dgst_pos0 = 0;
7073 dgst_pos1 = 3;
7074 dgst_pos2 = 2;
7075 dgst_pos3 = 1;
7076 break;
7077
7078 case 40: hash_type = HASH_TYPE_MD5;
7079 salt_type = SALT_TYPE_INTERN;
7080 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7081 opts_type = OPTS_TYPE_PT_GENERATE_LE
7082 | OPTS_TYPE_PT_ADD80
7083 | OPTS_TYPE_PT_ADDBITS14
7084 | OPTS_TYPE_PT_UNICODE;
7085 kern_type = KERN_TYPE_MD5_SLTPWU;
7086 dgst_size = DGST_SIZE_4_4;
7087 parse_func = md5s_parse_hash;
7088 sort_by_digest = sort_by_digest_4_4;
7089 opti_type = OPTI_TYPE_ZERO_BYTE
7090 | OPTI_TYPE_PRECOMPUTE_INIT
7091 | OPTI_TYPE_PRECOMPUTE_MERKLE
7092 | OPTI_TYPE_EARLY_SKIP
7093 | OPTI_TYPE_NOT_ITERATED
7094 | OPTI_TYPE_PREPENDED_SALT
7095 | OPTI_TYPE_RAW_HASH;
7096 dgst_pos0 = 0;
7097 dgst_pos1 = 3;
7098 dgst_pos2 = 2;
7099 dgst_pos3 = 1;
7100 break;
7101
7102 case 50: hash_type = HASH_TYPE_MD5;
7103 salt_type = SALT_TYPE_INTERN;
7104 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7105 opts_type = OPTS_TYPE_PT_GENERATE_LE
7106 | OPTS_TYPE_ST_ADD80
7107 | OPTS_TYPE_ST_ADDBITS14;
7108 kern_type = KERN_TYPE_HMACMD5_PW;
7109 dgst_size = DGST_SIZE_4_4;
7110 parse_func = hmacmd5_parse_hash;
7111 sort_by_digest = sort_by_digest_4_4;
7112 opti_type = OPTI_TYPE_ZERO_BYTE
7113 | OPTI_TYPE_NOT_ITERATED;
7114 dgst_pos0 = 0;
7115 dgst_pos1 = 3;
7116 dgst_pos2 = 2;
7117 dgst_pos3 = 1;
7118 break;
7119
7120 case 60: hash_type = HASH_TYPE_MD5;
7121 salt_type = SALT_TYPE_INTERN;
7122 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7123 opts_type = OPTS_TYPE_PT_GENERATE_LE
7124 | OPTS_TYPE_PT_ADD80
7125 | OPTS_TYPE_PT_ADDBITS14;
7126 kern_type = KERN_TYPE_HMACMD5_SLT;
7127 dgst_size = DGST_SIZE_4_4;
7128 parse_func = hmacmd5_parse_hash;
7129 sort_by_digest = sort_by_digest_4_4;
7130 opti_type = OPTI_TYPE_ZERO_BYTE
7131 | OPTI_TYPE_NOT_ITERATED;
7132 dgst_pos0 = 0;
7133 dgst_pos1 = 3;
7134 dgst_pos2 = 2;
7135 dgst_pos3 = 1;
7136 break;
7137
7138 case 100: hash_type = HASH_TYPE_SHA1;
7139 salt_type = SALT_TYPE_NONE;
7140 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7141 opts_type = OPTS_TYPE_PT_GENERATE_BE
7142 | OPTS_TYPE_PT_ADD80
7143 | OPTS_TYPE_PT_ADDBITS15;
7144 kern_type = KERN_TYPE_SHA1;
7145 dgst_size = DGST_SIZE_4_5;
7146 parse_func = sha1_parse_hash;
7147 sort_by_digest = sort_by_digest_4_5;
7148 opti_type = OPTI_TYPE_ZERO_BYTE
7149 | OPTI_TYPE_PRECOMPUTE_INIT
7150 | OPTI_TYPE_PRECOMPUTE_MERKLE
7151 | OPTI_TYPE_EARLY_SKIP
7152 | OPTI_TYPE_NOT_ITERATED
7153 | OPTI_TYPE_NOT_SALTED
7154 | OPTI_TYPE_RAW_HASH;
7155 dgst_pos0 = 3;
7156 dgst_pos1 = 4;
7157 dgst_pos2 = 2;
7158 dgst_pos3 = 1;
7159 break;
7160
7161 case 101: hash_type = HASH_TYPE_SHA1;
7162 salt_type = SALT_TYPE_NONE;
7163 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7164 opts_type = OPTS_TYPE_PT_GENERATE_BE
7165 | OPTS_TYPE_PT_ADD80
7166 | OPTS_TYPE_PT_ADDBITS15;
7167 kern_type = KERN_TYPE_SHA1;
7168 dgst_size = DGST_SIZE_4_5;
7169 parse_func = sha1b64_parse_hash;
7170 sort_by_digest = sort_by_digest_4_5;
7171 opti_type = OPTI_TYPE_ZERO_BYTE
7172 | OPTI_TYPE_PRECOMPUTE_INIT
7173 | OPTI_TYPE_PRECOMPUTE_MERKLE
7174 | OPTI_TYPE_EARLY_SKIP
7175 | OPTI_TYPE_NOT_ITERATED
7176 | OPTI_TYPE_NOT_SALTED
7177 | OPTI_TYPE_RAW_HASH;
7178 dgst_pos0 = 3;
7179 dgst_pos1 = 4;
7180 dgst_pos2 = 2;
7181 dgst_pos3 = 1;
7182 break;
7183
7184 case 110: hash_type = HASH_TYPE_SHA1;
7185 salt_type = SALT_TYPE_INTERN;
7186 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7187 opts_type = OPTS_TYPE_PT_GENERATE_BE
7188 | OPTS_TYPE_ST_ADD80
7189 | OPTS_TYPE_ST_ADDBITS15;
7190 kern_type = KERN_TYPE_SHA1_PWSLT;
7191 dgst_size = DGST_SIZE_4_5;
7192 parse_func = sha1s_parse_hash;
7193 sort_by_digest = sort_by_digest_4_5;
7194 opti_type = OPTI_TYPE_ZERO_BYTE
7195 | OPTI_TYPE_PRECOMPUTE_INIT
7196 | OPTI_TYPE_PRECOMPUTE_MERKLE
7197 | OPTI_TYPE_EARLY_SKIP
7198 | OPTI_TYPE_NOT_ITERATED
7199 | OPTI_TYPE_APPENDED_SALT
7200 | OPTI_TYPE_RAW_HASH;
7201 dgst_pos0 = 3;
7202 dgst_pos1 = 4;
7203 dgst_pos2 = 2;
7204 dgst_pos3 = 1;
7205 break;
7206
7207 case 111: hash_type = HASH_TYPE_SHA1;
7208 salt_type = SALT_TYPE_EMBEDDED;
7209 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7210 opts_type = OPTS_TYPE_PT_GENERATE_BE
7211 | OPTS_TYPE_ST_ADD80
7212 | OPTS_TYPE_ST_ADDBITS15;
7213 kern_type = KERN_TYPE_SHA1_PWSLT;
7214 dgst_size = DGST_SIZE_4_5;
7215 parse_func = sha1b64s_parse_hash;
7216 sort_by_digest = sort_by_digest_4_5;
7217 opti_type = OPTI_TYPE_ZERO_BYTE
7218 | OPTI_TYPE_PRECOMPUTE_INIT
7219 | OPTI_TYPE_PRECOMPUTE_MERKLE
7220 | OPTI_TYPE_EARLY_SKIP
7221 | OPTI_TYPE_NOT_ITERATED
7222 | OPTI_TYPE_APPENDED_SALT
7223 | OPTI_TYPE_RAW_HASH;
7224 dgst_pos0 = 3;
7225 dgst_pos1 = 4;
7226 dgst_pos2 = 2;
7227 dgst_pos3 = 1;
7228 break;
7229
7230 case 112: hash_type = HASH_TYPE_SHA1;
7231 salt_type = SALT_TYPE_INTERN;
7232 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7233 opts_type = OPTS_TYPE_PT_GENERATE_BE
7234 | OPTS_TYPE_ST_ADD80
7235 | OPTS_TYPE_ST_ADDBITS15
7236 | OPTS_TYPE_ST_HEX;
7237 kern_type = KERN_TYPE_SHA1_PWSLT;
7238 dgst_size = DGST_SIZE_4_5;
7239 parse_func = oracles_parse_hash;
7240 sort_by_digest = sort_by_digest_4_5;
7241 opti_type = OPTI_TYPE_ZERO_BYTE
7242 | OPTI_TYPE_PRECOMPUTE_INIT
7243 | OPTI_TYPE_PRECOMPUTE_MERKLE
7244 | OPTI_TYPE_EARLY_SKIP
7245 | OPTI_TYPE_NOT_ITERATED
7246 | OPTI_TYPE_APPENDED_SALT
7247 | OPTI_TYPE_RAW_HASH;
7248 dgst_pos0 = 3;
7249 dgst_pos1 = 4;
7250 dgst_pos2 = 2;
7251 dgst_pos3 = 1;
7252 break;
7253
7254 case 120: hash_type = HASH_TYPE_SHA1;
7255 salt_type = SALT_TYPE_INTERN;
7256 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7257 opts_type = OPTS_TYPE_PT_GENERATE_BE
7258 | OPTS_TYPE_PT_ADD80
7259 | OPTS_TYPE_PT_ADDBITS15;
7260 kern_type = KERN_TYPE_SHA1_SLTPW;
7261 dgst_size = DGST_SIZE_4_5;
7262 parse_func = sha1s_parse_hash;
7263 sort_by_digest = sort_by_digest_4_5;
7264 opti_type = OPTI_TYPE_ZERO_BYTE
7265 | OPTI_TYPE_PRECOMPUTE_INIT
7266 | OPTI_TYPE_PRECOMPUTE_MERKLE
7267 | OPTI_TYPE_EARLY_SKIP
7268 | OPTI_TYPE_NOT_ITERATED
7269 | OPTI_TYPE_PREPENDED_SALT
7270 | OPTI_TYPE_RAW_HASH;
7271 dgst_pos0 = 3;
7272 dgst_pos1 = 4;
7273 dgst_pos2 = 2;
7274 dgst_pos3 = 1;
7275 break;
7276
7277 case 121: hash_type = HASH_TYPE_SHA1;
7278 salt_type = SALT_TYPE_INTERN;
7279 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7280 opts_type = OPTS_TYPE_PT_GENERATE_BE
7281 | OPTS_TYPE_PT_ADD80
7282 | OPTS_TYPE_PT_ADDBITS15
7283 | OPTS_TYPE_ST_LOWER;
7284 kern_type = KERN_TYPE_SHA1_SLTPW;
7285 dgst_size = DGST_SIZE_4_5;
7286 parse_func = smf_parse_hash;
7287 sort_by_digest = sort_by_digest_4_5;
7288 opti_type = OPTI_TYPE_ZERO_BYTE
7289 | OPTI_TYPE_PRECOMPUTE_INIT
7290 | OPTI_TYPE_PRECOMPUTE_MERKLE
7291 | OPTI_TYPE_EARLY_SKIP
7292 | OPTI_TYPE_NOT_ITERATED
7293 | OPTI_TYPE_PREPENDED_SALT
7294 | OPTI_TYPE_RAW_HASH;
7295 dgst_pos0 = 3;
7296 dgst_pos1 = 4;
7297 dgst_pos2 = 2;
7298 dgst_pos3 = 1;
7299 break;
7300
7301 case 122: hash_type = HASH_TYPE_SHA1;
7302 salt_type = SALT_TYPE_EMBEDDED;
7303 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7304 opts_type = OPTS_TYPE_PT_GENERATE_BE
7305 | OPTS_TYPE_PT_ADD80
7306 | OPTS_TYPE_PT_ADDBITS15
7307 | OPTS_TYPE_ST_HEX;
7308 kern_type = KERN_TYPE_SHA1_SLTPW;
7309 dgst_size = DGST_SIZE_4_5;
7310 parse_func = osx1_parse_hash;
7311 sort_by_digest = sort_by_digest_4_5;
7312 opti_type = OPTI_TYPE_ZERO_BYTE
7313 | OPTI_TYPE_PRECOMPUTE_INIT
7314 | OPTI_TYPE_PRECOMPUTE_MERKLE
7315 | OPTI_TYPE_EARLY_SKIP
7316 | OPTI_TYPE_NOT_ITERATED
7317 | OPTI_TYPE_PREPENDED_SALT
7318 | OPTI_TYPE_RAW_HASH;
7319 dgst_pos0 = 3;
7320 dgst_pos1 = 4;
7321 dgst_pos2 = 2;
7322 dgst_pos3 = 1;
7323 break;
7324
7325 case 124: hash_type = HASH_TYPE_SHA1;
7326 salt_type = SALT_TYPE_EMBEDDED;
7327 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7328 opts_type = OPTS_TYPE_PT_GENERATE_BE
7329 | OPTS_TYPE_PT_ADD80
7330 | OPTS_TYPE_PT_ADDBITS15;
7331 kern_type = KERN_TYPE_SHA1_SLTPW;
7332 dgst_size = DGST_SIZE_4_5;
7333 parse_func = djangosha1_parse_hash;
7334 sort_by_digest = sort_by_digest_4_5;
7335 opti_type = OPTI_TYPE_ZERO_BYTE
7336 | OPTI_TYPE_PRECOMPUTE_INIT
7337 | OPTI_TYPE_PRECOMPUTE_MERKLE
7338 | OPTI_TYPE_EARLY_SKIP
7339 | OPTI_TYPE_NOT_ITERATED
7340 | OPTI_TYPE_PREPENDED_SALT
7341 | OPTI_TYPE_RAW_HASH;
7342 dgst_pos0 = 3;
7343 dgst_pos1 = 4;
7344 dgst_pos2 = 2;
7345 dgst_pos3 = 1;
7346 break;
7347
7348 case 125: hash_type = HASH_TYPE_SHA1;
7349 salt_type = SALT_TYPE_EMBEDDED;
7350 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7351 opts_type = OPTS_TYPE_PT_GENERATE_BE
7352 | OPTS_TYPE_PT_ADD80
7353 | OPTS_TYPE_PT_ADDBITS15
7354 | OPTS_TYPE_ST_HEX;
7355 kern_type = KERN_TYPE_SHA1_SLTPW;
7356 dgst_size = DGST_SIZE_4_5;
7357 parse_func = arubaos_parse_hash;
7358 sort_by_digest = sort_by_digest_4_5;
7359 opti_type = OPTI_TYPE_ZERO_BYTE
7360 | OPTI_TYPE_PRECOMPUTE_INIT
7361 | OPTI_TYPE_PRECOMPUTE_MERKLE
7362 | OPTI_TYPE_EARLY_SKIP
7363 | OPTI_TYPE_NOT_ITERATED
7364 | OPTI_TYPE_PREPENDED_SALT
7365 | OPTI_TYPE_RAW_HASH;
7366 dgst_pos0 = 3;
7367 dgst_pos1 = 4;
7368 dgst_pos2 = 2;
7369 dgst_pos3 = 1;
7370 break;
7371
7372 case 130: hash_type = HASH_TYPE_SHA1;
7373 salt_type = SALT_TYPE_INTERN;
7374 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7375 opts_type = OPTS_TYPE_PT_GENERATE_BE
7376 | OPTS_TYPE_PT_UNICODE
7377 | OPTS_TYPE_ST_ADD80
7378 | OPTS_TYPE_ST_ADDBITS15;
7379 kern_type = KERN_TYPE_SHA1_PWUSLT;
7380 dgst_size = DGST_SIZE_4_5;
7381 parse_func = sha1s_parse_hash;
7382 sort_by_digest = sort_by_digest_4_5;
7383 opti_type = OPTI_TYPE_ZERO_BYTE
7384 | OPTI_TYPE_PRECOMPUTE_INIT
7385 | OPTI_TYPE_PRECOMPUTE_MERKLE
7386 | OPTI_TYPE_EARLY_SKIP
7387 | OPTI_TYPE_NOT_ITERATED
7388 | OPTI_TYPE_APPENDED_SALT
7389 | OPTI_TYPE_RAW_HASH;
7390 dgst_pos0 = 3;
7391 dgst_pos1 = 4;
7392 dgst_pos2 = 2;
7393 dgst_pos3 = 1;
7394 break;
7395
7396 case 131: hash_type = HASH_TYPE_SHA1;
7397 salt_type = SALT_TYPE_EMBEDDED;
7398 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7399 opts_type = OPTS_TYPE_PT_GENERATE_BE
7400 | OPTS_TYPE_PT_UNICODE
7401 | OPTS_TYPE_PT_UPPER
7402 | OPTS_TYPE_ST_ADD80
7403 | OPTS_TYPE_ST_ADDBITS15
7404 | OPTS_TYPE_ST_HEX;
7405 kern_type = KERN_TYPE_SHA1_PWUSLT;
7406 dgst_size = DGST_SIZE_4_5;
7407 parse_func = mssql2000_parse_hash;
7408 sort_by_digest = sort_by_digest_4_5;
7409 opti_type = OPTI_TYPE_ZERO_BYTE
7410 | OPTI_TYPE_PRECOMPUTE_INIT
7411 | OPTI_TYPE_PRECOMPUTE_MERKLE
7412 | OPTI_TYPE_EARLY_SKIP
7413 | OPTI_TYPE_NOT_ITERATED
7414 | OPTI_TYPE_APPENDED_SALT
7415 | OPTI_TYPE_RAW_HASH;
7416 dgst_pos0 = 3;
7417 dgst_pos1 = 4;
7418 dgst_pos2 = 2;
7419 dgst_pos3 = 1;
7420 break;
7421
7422 case 132: hash_type = HASH_TYPE_SHA1;
7423 salt_type = SALT_TYPE_EMBEDDED;
7424 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7425 opts_type = OPTS_TYPE_PT_GENERATE_BE
7426 | OPTS_TYPE_PT_UNICODE
7427 | OPTS_TYPE_ST_ADD80
7428 | OPTS_TYPE_ST_ADDBITS15
7429 | OPTS_TYPE_ST_HEX;
7430 kern_type = KERN_TYPE_SHA1_PWUSLT;
7431 dgst_size = DGST_SIZE_4_5;
7432 parse_func = mssql2005_parse_hash;
7433 sort_by_digest = sort_by_digest_4_5;
7434 opti_type = OPTI_TYPE_ZERO_BYTE
7435 | OPTI_TYPE_PRECOMPUTE_INIT
7436 | OPTI_TYPE_PRECOMPUTE_MERKLE
7437 | OPTI_TYPE_EARLY_SKIP
7438 | OPTI_TYPE_NOT_ITERATED
7439 | OPTI_TYPE_APPENDED_SALT
7440 | OPTI_TYPE_RAW_HASH;
7441 dgst_pos0 = 3;
7442 dgst_pos1 = 4;
7443 dgst_pos2 = 2;
7444 dgst_pos3 = 1;
7445 break;
7446
7447 case 133: hash_type = HASH_TYPE_SHA1;
7448 salt_type = SALT_TYPE_EMBEDDED;
7449 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7450 opts_type = OPTS_TYPE_PT_GENERATE_BE
7451 | OPTS_TYPE_PT_UNICODE
7452 | OPTS_TYPE_ST_ADD80
7453 | OPTS_TYPE_ST_ADDBITS15;
7454 kern_type = KERN_TYPE_SHA1_PWUSLT;
7455 dgst_size = DGST_SIZE_4_5;
7456 parse_func = peoplesoft_parse_hash;
7457 sort_by_digest = sort_by_digest_4_5;
7458 opti_type = OPTI_TYPE_ZERO_BYTE
7459 | OPTI_TYPE_PRECOMPUTE_INIT
7460 | OPTI_TYPE_PRECOMPUTE_MERKLE
7461 | OPTI_TYPE_EARLY_SKIP
7462 | OPTI_TYPE_NOT_ITERATED
7463 | OPTI_TYPE_APPENDED_SALT
7464 | OPTI_TYPE_RAW_HASH;
7465 dgst_pos0 = 3;
7466 dgst_pos1 = 4;
7467 dgst_pos2 = 2;
7468 dgst_pos3 = 1;
7469 break;
7470
7471 case 140: hash_type = HASH_TYPE_SHA1;
7472 salt_type = SALT_TYPE_INTERN;
7473 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7474 opts_type = OPTS_TYPE_PT_GENERATE_BE
7475 | OPTS_TYPE_PT_ADD80
7476 | OPTS_TYPE_PT_ADDBITS15
7477 | OPTS_TYPE_PT_UNICODE;
7478 kern_type = KERN_TYPE_SHA1_SLTPWU;
7479 dgst_size = DGST_SIZE_4_5;
7480 parse_func = sha1s_parse_hash;
7481 sort_by_digest = sort_by_digest_4_5;
7482 opti_type = OPTI_TYPE_ZERO_BYTE
7483 | OPTI_TYPE_PRECOMPUTE_INIT
7484 | OPTI_TYPE_PRECOMPUTE_MERKLE
7485 | OPTI_TYPE_EARLY_SKIP
7486 | OPTI_TYPE_NOT_ITERATED
7487 | OPTI_TYPE_PREPENDED_SALT
7488 | OPTI_TYPE_RAW_HASH;
7489 dgst_pos0 = 3;
7490 dgst_pos1 = 4;
7491 dgst_pos2 = 2;
7492 dgst_pos3 = 1;
7493 break;
7494
7495 case 141: hash_type = HASH_TYPE_SHA1;
7496 salt_type = SALT_TYPE_EMBEDDED;
7497 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7498 opts_type = OPTS_TYPE_PT_GENERATE_BE
7499 | OPTS_TYPE_PT_ADD80
7500 | OPTS_TYPE_PT_ADDBITS15
7501 | OPTS_TYPE_PT_UNICODE
7502 | OPTS_TYPE_ST_BASE64;
7503 kern_type = KERN_TYPE_SHA1_SLTPWU;
7504 dgst_size = DGST_SIZE_4_5;
7505 parse_func = episerver_parse_hash;
7506 sort_by_digest = sort_by_digest_4_5;
7507 opti_type = OPTI_TYPE_ZERO_BYTE
7508 | OPTI_TYPE_PRECOMPUTE_INIT
7509 | OPTI_TYPE_PRECOMPUTE_MERKLE
7510 | OPTI_TYPE_EARLY_SKIP
7511 | OPTI_TYPE_NOT_ITERATED
7512 | OPTI_TYPE_PREPENDED_SALT
7513 | OPTI_TYPE_RAW_HASH;
7514 dgst_pos0 = 3;
7515 dgst_pos1 = 4;
7516 dgst_pos2 = 2;
7517 dgst_pos3 = 1;
7518 break;
7519
7520 case 150: hash_type = HASH_TYPE_SHA1;
7521 salt_type = SALT_TYPE_INTERN;
7522 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7523 opts_type = OPTS_TYPE_PT_GENERATE_BE
7524 | OPTS_TYPE_ST_ADD80
7525 | OPTS_TYPE_ST_ADDBITS15;
7526 kern_type = KERN_TYPE_HMACSHA1_PW;
7527 dgst_size = DGST_SIZE_4_5;
7528 parse_func = hmacsha1_parse_hash;
7529 sort_by_digest = sort_by_digest_4_5;
7530 opti_type = OPTI_TYPE_ZERO_BYTE
7531 | OPTI_TYPE_NOT_ITERATED;
7532 dgst_pos0 = 3;
7533 dgst_pos1 = 4;
7534 dgst_pos2 = 2;
7535 dgst_pos3 = 1;
7536 break;
7537
7538 case 160: hash_type = HASH_TYPE_SHA1;
7539 salt_type = SALT_TYPE_INTERN;
7540 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7541 opts_type = OPTS_TYPE_PT_GENERATE_BE
7542 | OPTS_TYPE_PT_ADD80
7543 | OPTS_TYPE_PT_ADDBITS15;
7544 kern_type = KERN_TYPE_HMACSHA1_SLT;
7545 dgst_size = DGST_SIZE_4_5;
7546 parse_func = hmacsha1_parse_hash;
7547 sort_by_digest = sort_by_digest_4_5;
7548 opti_type = OPTI_TYPE_ZERO_BYTE
7549 | OPTI_TYPE_NOT_ITERATED;
7550 dgst_pos0 = 3;
7551 dgst_pos1 = 4;
7552 dgst_pos2 = 2;
7553 dgst_pos3 = 1;
7554 break;
7555
7556 case 190: hash_type = HASH_TYPE_SHA1;
7557 salt_type = SALT_TYPE_NONE;
7558 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7559 opts_type = OPTS_TYPE_PT_GENERATE_BE
7560 | OPTS_TYPE_PT_ADD80
7561 | OPTS_TYPE_PT_ADDBITS15;
7562 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7563 dgst_size = DGST_SIZE_4_5;
7564 parse_func = sha1linkedin_parse_hash;
7565 sort_by_digest = sort_by_digest_4_5;
7566 opti_type = OPTI_TYPE_ZERO_BYTE
7567 | OPTI_TYPE_PRECOMPUTE_INIT
7568 | OPTI_TYPE_EARLY_SKIP
7569 | OPTI_TYPE_NOT_ITERATED
7570 | OPTI_TYPE_NOT_SALTED;
7571 dgst_pos0 = 0;
7572 dgst_pos1 = 4;
7573 dgst_pos2 = 3;
7574 dgst_pos3 = 2;
7575 break;
7576
7577 case 200: hash_type = HASH_TYPE_MYSQL;
7578 salt_type = SALT_TYPE_NONE;
7579 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7580 opts_type = 0;
7581 kern_type = KERN_TYPE_MYSQL;
7582 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7583 parse_func = mysql323_parse_hash;
7584 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7585 opti_type = OPTI_TYPE_ZERO_BYTE;
7586 dgst_pos0 = 0;
7587 dgst_pos1 = 1;
7588 dgst_pos2 = 2;
7589 dgst_pos3 = 3;
7590 break;
7591
7592 case 300: hash_type = HASH_TYPE_SHA1;
7593 salt_type = SALT_TYPE_NONE;
7594 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7595 opts_type = OPTS_TYPE_PT_GENERATE_BE
7596 | OPTS_TYPE_PT_ADD80
7597 | OPTS_TYPE_PT_ADDBITS15;
7598 kern_type = KERN_TYPE_MYSQL41;
7599 dgst_size = DGST_SIZE_4_5;
7600 parse_func = sha1_parse_hash;
7601 sort_by_digest = sort_by_digest_4_5;
7602 opti_type = OPTI_TYPE_ZERO_BYTE
7603 | OPTI_TYPE_PRECOMPUTE_INIT
7604 | OPTI_TYPE_PRECOMPUTE_MERKLE
7605 | OPTI_TYPE_EARLY_SKIP
7606 | OPTI_TYPE_NOT_ITERATED
7607 | OPTI_TYPE_NOT_SALTED;
7608 dgst_pos0 = 3;
7609 dgst_pos1 = 4;
7610 dgst_pos2 = 2;
7611 dgst_pos3 = 1;
7612 break;
7613
7614 case 400: hash_type = HASH_TYPE_MD5;
7615 salt_type = SALT_TYPE_EMBEDDED;
7616 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7617 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7618 kern_type = KERN_TYPE_PHPASS;
7619 dgst_size = DGST_SIZE_4_4;
7620 parse_func = phpass_parse_hash;
7621 sort_by_digest = sort_by_digest_4_4;
7622 opti_type = OPTI_TYPE_ZERO_BYTE;
7623 dgst_pos0 = 0;
7624 dgst_pos1 = 1;
7625 dgst_pos2 = 2;
7626 dgst_pos3 = 3;
7627 break;
7628
7629 case 500: hash_type = HASH_TYPE_MD5;
7630 salt_type = SALT_TYPE_EMBEDDED;
7631 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7632 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7633 kern_type = KERN_TYPE_MD5CRYPT;
7634 dgst_size = DGST_SIZE_4_4;
7635 parse_func = md5crypt_parse_hash;
7636 sort_by_digest = sort_by_digest_4_4;
7637 opti_type = OPTI_TYPE_ZERO_BYTE;
7638 dgst_pos0 = 0;
7639 dgst_pos1 = 1;
7640 dgst_pos2 = 2;
7641 dgst_pos3 = 3;
7642 break;
7643
7644 case 501: hash_type = HASH_TYPE_MD5;
7645 salt_type = SALT_TYPE_EMBEDDED;
7646 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7647 opts_type = OPTS_TYPE_PT_GENERATE_LE
7648 | OPTS_TYPE_HASH_COPY;
7649 kern_type = KERN_TYPE_MD5CRYPT;
7650 dgst_size = DGST_SIZE_4_4;
7651 parse_func = juniper_parse_hash;
7652 sort_by_digest = sort_by_digest_4_4;
7653 opti_type = OPTI_TYPE_ZERO_BYTE;
7654 dgst_pos0 = 0;
7655 dgst_pos1 = 1;
7656 dgst_pos2 = 2;
7657 dgst_pos3 = 3;
7658 break;
7659
7660 case 900: hash_type = HASH_TYPE_MD4;
7661 salt_type = SALT_TYPE_NONE;
7662 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7663 opts_type = OPTS_TYPE_PT_GENERATE_LE
7664 | OPTS_TYPE_PT_ADD80
7665 | OPTS_TYPE_PT_ADDBITS14;
7666 kern_type = KERN_TYPE_MD4;
7667 dgst_size = DGST_SIZE_4_4;
7668 parse_func = md4_parse_hash;
7669 sort_by_digest = sort_by_digest_4_4;
7670 opti_type = OPTI_TYPE_ZERO_BYTE
7671 | OPTI_TYPE_PRECOMPUTE_INIT
7672 | OPTI_TYPE_PRECOMPUTE_MERKLE
7673 | OPTI_TYPE_MEET_IN_MIDDLE
7674 | OPTI_TYPE_EARLY_SKIP
7675 | OPTI_TYPE_NOT_ITERATED
7676 | OPTI_TYPE_NOT_SALTED
7677 | OPTI_TYPE_RAW_HASH;
7678 dgst_pos0 = 0;
7679 dgst_pos1 = 3;
7680 dgst_pos2 = 2;
7681 dgst_pos3 = 1;
7682 break;
7683
7684 case 1000: hash_type = HASH_TYPE_MD4;
7685 salt_type = SALT_TYPE_NONE;
7686 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7687 opts_type = OPTS_TYPE_PT_GENERATE_LE
7688 | OPTS_TYPE_PT_ADD80
7689 | OPTS_TYPE_PT_ADDBITS14
7690 | OPTS_TYPE_PT_UNICODE;
7691 kern_type = KERN_TYPE_MD4_PWU;
7692 dgst_size = DGST_SIZE_4_4;
7693 parse_func = md4_parse_hash;
7694 sort_by_digest = sort_by_digest_4_4;
7695 opti_type = OPTI_TYPE_ZERO_BYTE
7696 | OPTI_TYPE_PRECOMPUTE_INIT
7697 | OPTI_TYPE_PRECOMPUTE_MERKLE
7698 | OPTI_TYPE_MEET_IN_MIDDLE
7699 | OPTI_TYPE_EARLY_SKIP
7700 | OPTI_TYPE_NOT_ITERATED
7701 | OPTI_TYPE_NOT_SALTED
7702 | OPTI_TYPE_RAW_HASH;
7703 dgst_pos0 = 0;
7704 dgst_pos1 = 3;
7705 dgst_pos2 = 2;
7706 dgst_pos3 = 1;
7707 break;
7708
7709 case 1100: hash_type = HASH_TYPE_MD4;
7710 salt_type = SALT_TYPE_INTERN;
7711 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7712 opts_type = OPTS_TYPE_PT_GENERATE_LE
7713 | OPTS_TYPE_PT_ADD80
7714 | OPTS_TYPE_PT_ADDBITS14
7715 | OPTS_TYPE_PT_UNICODE
7716 | OPTS_TYPE_ST_ADD80
7717 | OPTS_TYPE_ST_UNICODE
7718 | OPTS_TYPE_ST_LOWER;
7719 kern_type = KERN_TYPE_MD44_PWUSLT;
7720 dgst_size = DGST_SIZE_4_4;
7721 parse_func = dcc_parse_hash;
7722 sort_by_digest = sort_by_digest_4_4;
7723 opti_type = OPTI_TYPE_ZERO_BYTE
7724 | OPTI_TYPE_PRECOMPUTE_INIT
7725 | OPTI_TYPE_PRECOMPUTE_MERKLE
7726 | OPTI_TYPE_EARLY_SKIP
7727 | OPTI_TYPE_NOT_ITERATED;
7728 dgst_pos0 = 0;
7729 dgst_pos1 = 3;
7730 dgst_pos2 = 2;
7731 dgst_pos3 = 1;
7732 break;
7733
7734 case 1400: hash_type = HASH_TYPE_SHA256;
7735 salt_type = SALT_TYPE_NONE;
7736 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7737 opts_type = OPTS_TYPE_PT_GENERATE_BE
7738 | OPTS_TYPE_PT_ADD80
7739 | OPTS_TYPE_PT_ADDBITS15;
7740 kern_type = KERN_TYPE_SHA256;
7741 dgst_size = DGST_SIZE_4_8;
7742 parse_func = sha256_parse_hash;
7743 sort_by_digest = sort_by_digest_4_8;
7744 opti_type = OPTI_TYPE_ZERO_BYTE
7745 | OPTI_TYPE_PRECOMPUTE_INIT
7746 | OPTI_TYPE_PRECOMPUTE_MERKLE
7747 | OPTI_TYPE_EARLY_SKIP
7748 | OPTI_TYPE_NOT_ITERATED
7749 | OPTI_TYPE_NOT_SALTED
7750 | OPTI_TYPE_RAW_HASH;
7751 dgst_pos0 = 3;
7752 dgst_pos1 = 7;
7753 dgst_pos2 = 2;
7754 dgst_pos3 = 6;
7755 break;
7756
7757 case 1410: hash_type = HASH_TYPE_SHA256;
7758 salt_type = SALT_TYPE_INTERN;
7759 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7760 opts_type = OPTS_TYPE_PT_GENERATE_BE
7761 | OPTS_TYPE_ST_ADD80
7762 | OPTS_TYPE_ST_ADDBITS15;
7763 kern_type = KERN_TYPE_SHA256_PWSLT;
7764 dgst_size = DGST_SIZE_4_8;
7765 parse_func = sha256s_parse_hash;
7766 sort_by_digest = sort_by_digest_4_8;
7767 opti_type = OPTI_TYPE_ZERO_BYTE
7768 | OPTI_TYPE_PRECOMPUTE_INIT
7769 | OPTI_TYPE_PRECOMPUTE_MERKLE
7770 | OPTI_TYPE_EARLY_SKIP
7771 | OPTI_TYPE_NOT_ITERATED
7772 | OPTI_TYPE_APPENDED_SALT
7773 | OPTI_TYPE_RAW_HASH;
7774 dgst_pos0 = 3;
7775 dgst_pos1 = 7;
7776 dgst_pos2 = 2;
7777 dgst_pos3 = 6;
7778 break;
7779
7780 case 1420: hash_type = HASH_TYPE_SHA256;
7781 salt_type = SALT_TYPE_INTERN;
7782 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7783 opts_type = OPTS_TYPE_PT_GENERATE_BE
7784 | OPTS_TYPE_PT_ADD80
7785 | OPTS_TYPE_PT_ADDBITS15;
7786 kern_type = KERN_TYPE_SHA256_SLTPW;
7787 dgst_size = DGST_SIZE_4_8;
7788 parse_func = sha256s_parse_hash;
7789 sort_by_digest = sort_by_digest_4_8;
7790 opti_type = OPTI_TYPE_ZERO_BYTE
7791 | OPTI_TYPE_PRECOMPUTE_INIT
7792 | OPTI_TYPE_PRECOMPUTE_MERKLE
7793 | OPTI_TYPE_EARLY_SKIP
7794 | OPTI_TYPE_NOT_ITERATED
7795 | OPTI_TYPE_PREPENDED_SALT
7796 | OPTI_TYPE_RAW_HASH;
7797 dgst_pos0 = 3;
7798 dgst_pos1 = 7;
7799 dgst_pos2 = 2;
7800 dgst_pos3 = 6;
7801 break;
7802
7803 case 1421: hash_type = HASH_TYPE_SHA256;
7804 salt_type = SALT_TYPE_EMBEDDED;
7805 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7806 opts_type = OPTS_TYPE_PT_GENERATE_BE
7807 | OPTS_TYPE_PT_ADD80
7808 | OPTS_TYPE_PT_ADDBITS15;
7809 kern_type = KERN_TYPE_SHA256_SLTPW;
7810 dgst_size = DGST_SIZE_4_8;
7811 parse_func = hmailserver_parse_hash;
7812 sort_by_digest = sort_by_digest_4_8;
7813 opti_type = OPTI_TYPE_ZERO_BYTE
7814 | OPTI_TYPE_PRECOMPUTE_INIT
7815 | OPTI_TYPE_PRECOMPUTE_MERKLE
7816 | OPTI_TYPE_EARLY_SKIP
7817 | OPTI_TYPE_NOT_ITERATED
7818 | OPTI_TYPE_PREPENDED_SALT
7819 | OPTI_TYPE_RAW_HASH;
7820 dgst_pos0 = 3;
7821 dgst_pos1 = 7;
7822 dgst_pos2 = 2;
7823 dgst_pos3 = 6;
7824 break;
7825
7826 case 1430: hash_type = HASH_TYPE_SHA256;
7827 salt_type = SALT_TYPE_INTERN;
7828 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7829 opts_type = OPTS_TYPE_PT_GENERATE_BE
7830 | OPTS_TYPE_PT_UNICODE
7831 | OPTS_TYPE_ST_ADD80
7832 | OPTS_TYPE_ST_ADDBITS15;
7833 kern_type = KERN_TYPE_SHA256_PWUSLT;
7834 dgst_size = DGST_SIZE_4_8;
7835 parse_func = sha256s_parse_hash;
7836 sort_by_digest = sort_by_digest_4_8;
7837 opti_type = OPTI_TYPE_ZERO_BYTE
7838 | OPTI_TYPE_PRECOMPUTE_INIT
7839 | OPTI_TYPE_PRECOMPUTE_MERKLE
7840 | OPTI_TYPE_EARLY_SKIP
7841 | OPTI_TYPE_NOT_ITERATED
7842 | OPTI_TYPE_APPENDED_SALT
7843 | OPTI_TYPE_RAW_HASH;
7844 dgst_pos0 = 3;
7845 dgst_pos1 = 7;
7846 dgst_pos2 = 2;
7847 dgst_pos3 = 6;
7848 break;
7849
7850 case 1440: hash_type = HASH_TYPE_SHA256;
7851 salt_type = SALT_TYPE_INTERN;
7852 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7853 opts_type = OPTS_TYPE_PT_GENERATE_BE
7854 | OPTS_TYPE_PT_ADD80
7855 | OPTS_TYPE_PT_ADDBITS15
7856 | OPTS_TYPE_PT_UNICODE;
7857 kern_type = KERN_TYPE_SHA256_SLTPWU;
7858 dgst_size = DGST_SIZE_4_8;
7859 parse_func = sha256s_parse_hash;
7860 sort_by_digest = sort_by_digest_4_8;
7861 opti_type = OPTI_TYPE_ZERO_BYTE
7862 | OPTI_TYPE_PRECOMPUTE_INIT
7863 | OPTI_TYPE_PRECOMPUTE_MERKLE
7864 | OPTI_TYPE_EARLY_SKIP
7865 | OPTI_TYPE_NOT_ITERATED
7866 | OPTI_TYPE_PREPENDED_SALT
7867 | OPTI_TYPE_RAW_HASH;
7868 dgst_pos0 = 3;
7869 dgst_pos1 = 7;
7870 dgst_pos2 = 2;
7871 dgst_pos3 = 6;
7872 break;
7873
7874 case 1441: hash_type = HASH_TYPE_SHA256;
7875 salt_type = SALT_TYPE_EMBEDDED;
7876 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7877 opts_type = OPTS_TYPE_PT_GENERATE_BE
7878 | OPTS_TYPE_PT_ADD80
7879 | OPTS_TYPE_PT_ADDBITS15
7880 | OPTS_TYPE_PT_UNICODE
7881 | OPTS_TYPE_ST_BASE64;
7882 kern_type = KERN_TYPE_SHA256_SLTPWU;
7883 dgst_size = DGST_SIZE_4_8;
7884 parse_func = episerver4_parse_hash;
7885 sort_by_digest = sort_by_digest_4_8;
7886 opti_type = OPTI_TYPE_ZERO_BYTE
7887 | OPTI_TYPE_PRECOMPUTE_INIT
7888 | OPTI_TYPE_PRECOMPUTE_MERKLE
7889 | OPTI_TYPE_EARLY_SKIP
7890 | OPTI_TYPE_NOT_ITERATED
7891 | OPTI_TYPE_PREPENDED_SALT
7892 | OPTI_TYPE_RAW_HASH;
7893 dgst_pos0 = 3;
7894 dgst_pos1 = 7;
7895 dgst_pos2 = 2;
7896 dgst_pos3 = 6;
7897 break;
7898
7899 case 1450: hash_type = HASH_TYPE_SHA256;
7900 salt_type = SALT_TYPE_INTERN;
7901 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7902 opts_type = OPTS_TYPE_PT_GENERATE_BE
7903 | OPTS_TYPE_ST_ADD80;
7904 kern_type = KERN_TYPE_HMACSHA256_PW;
7905 dgst_size = DGST_SIZE_4_8;
7906 parse_func = hmacsha256_parse_hash;
7907 sort_by_digest = sort_by_digest_4_8;
7908 opti_type = OPTI_TYPE_ZERO_BYTE
7909 | OPTI_TYPE_NOT_ITERATED;
7910 dgst_pos0 = 3;
7911 dgst_pos1 = 7;
7912 dgst_pos2 = 2;
7913 dgst_pos3 = 6;
7914 break;
7915
7916 case 1460: hash_type = HASH_TYPE_SHA256;
7917 salt_type = SALT_TYPE_INTERN;
7918 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7919 opts_type = OPTS_TYPE_PT_GENERATE_BE
7920 | OPTS_TYPE_PT_ADD80
7921 | OPTS_TYPE_PT_ADDBITS15;
7922 kern_type = KERN_TYPE_HMACSHA256_SLT;
7923 dgst_size = DGST_SIZE_4_8;
7924 parse_func = hmacsha256_parse_hash;
7925 sort_by_digest = sort_by_digest_4_8;
7926 opti_type = OPTI_TYPE_ZERO_BYTE
7927 | OPTI_TYPE_NOT_ITERATED;
7928 dgst_pos0 = 3;
7929 dgst_pos1 = 7;
7930 dgst_pos2 = 2;
7931 dgst_pos3 = 6;
7932 break;
7933
7934 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7935 salt_type = SALT_TYPE_EMBEDDED;
7936 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7937 opts_type = OPTS_TYPE_PT_GENERATE_LE
7938 | OPTS_TYPE_PT_BITSLICE;
7939 kern_type = KERN_TYPE_DESCRYPT;
7940 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7941 parse_func = descrypt_parse_hash;
7942 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7943 opti_type = OPTI_TYPE_ZERO_BYTE
7944 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7945 dgst_pos0 = 0;
7946 dgst_pos1 = 1;
7947 dgst_pos2 = 2;
7948 dgst_pos3 = 3;
7949 break;
7950
7951 case 1600: hash_type = HASH_TYPE_MD5;
7952 salt_type = SALT_TYPE_EMBEDDED;
7953 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7954 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7955 kern_type = KERN_TYPE_APR1CRYPT;
7956 dgst_size = DGST_SIZE_4_4;
7957 parse_func = md5apr1_parse_hash;
7958 sort_by_digest = sort_by_digest_4_4;
7959 opti_type = OPTI_TYPE_ZERO_BYTE;
7960 dgst_pos0 = 0;
7961 dgst_pos1 = 1;
7962 dgst_pos2 = 2;
7963 dgst_pos3 = 3;
7964 break;
7965
7966 case 1700: hash_type = HASH_TYPE_SHA512;
7967 salt_type = SALT_TYPE_NONE;
7968 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7969 opts_type = OPTS_TYPE_PT_GENERATE_BE
7970 | OPTS_TYPE_PT_ADD80
7971 | OPTS_TYPE_PT_ADDBITS15;
7972 kern_type = KERN_TYPE_SHA512;
7973 dgst_size = DGST_SIZE_8_8;
7974 parse_func = sha512_parse_hash;
7975 sort_by_digest = sort_by_digest_8_8;
7976 opti_type = OPTI_TYPE_ZERO_BYTE
7977 | OPTI_TYPE_PRECOMPUTE_INIT
7978 | OPTI_TYPE_PRECOMPUTE_MERKLE
7979 | OPTI_TYPE_EARLY_SKIP
7980 | OPTI_TYPE_NOT_ITERATED
7981 | OPTI_TYPE_NOT_SALTED
7982 | OPTI_TYPE_USES_BITS_64
7983 | OPTI_TYPE_RAW_HASH;
7984 dgst_pos0 = 14;
7985 dgst_pos1 = 15;
7986 dgst_pos2 = 6;
7987 dgst_pos3 = 7;
7988 break;
7989
7990 case 1710: hash_type = HASH_TYPE_SHA512;
7991 salt_type = SALT_TYPE_INTERN;
7992 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7993 opts_type = OPTS_TYPE_PT_GENERATE_BE
7994 | OPTS_TYPE_ST_ADD80
7995 | OPTS_TYPE_ST_ADDBITS15;
7996 kern_type = KERN_TYPE_SHA512_PWSLT;
7997 dgst_size = DGST_SIZE_8_8;
7998 parse_func = sha512s_parse_hash;
7999 sort_by_digest = sort_by_digest_8_8;
8000 opti_type = OPTI_TYPE_ZERO_BYTE
8001 | OPTI_TYPE_PRECOMPUTE_INIT
8002 | OPTI_TYPE_PRECOMPUTE_MERKLE
8003 | OPTI_TYPE_EARLY_SKIP
8004 | OPTI_TYPE_NOT_ITERATED
8005 | OPTI_TYPE_APPENDED_SALT
8006 | OPTI_TYPE_USES_BITS_64
8007 | OPTI_TYPE_RAW_HASH;
8008 dgst_pos0 = 14;
8009 dgst_pos1 = 15;
8010 dgst_pos2 = 6;
8011 dgst_pos3 = 7;
8012 break;
8013
8014 case 1711: hash_type = HASH_TYPE_SHA512;
8015 salt_type = SALT_TYPE_EMBEDDED;
8016 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8017 opts_type = OPTS_TYPE_PT_GENERATE_BE
8018 | OPTS_TYPE_ST_ADD80
8019 | OPTS_TYPE_ST_ADDBITS15;
8020 kern_type = KERN_TYPE_SHA512_PWSLT;
8021 dgst_size = DGST_SIZE_8_8;
8022 parse_func = sha512b64s_parse_hash;
8023 sort_by_digest = sort_by_digest_8_8;
8024 opti_type = OPTI_TYPE_ZERO_BYTE
8025 | OPTI_TYPE_PRECOMPUTE_INIT
8026 | OPTI_TYPE_PRECOMPUTE_MERKLE
8027 | OPTI_TYPE_EARLY_SKIP
8028 | OPTI_TYPE_NOT_ITERATED
8029 | OPTI_TYPE_APPENDED_SALT
8030 | OPTI_TYPE_USES_BITS_64
8031 | OPTI_TYPE_RAW_HASH;
8032 dgst_pos0 = 14;
8033 dgst_pos1 = 15;
8034 dgst_pos2 = 6;
8035 dgst_pos3 = 7;
8036 break;
8037
8038 case 1720: hash_type = HASH_TYPE_SHA512;
8039 salt_type = SALT_TYPE_INTERN;
8040 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8041 opts_type = OPTS_TYPE_PT_GENERATE_BE
8042 | OPTS_TYPE_PT_ADD80
8043 | OPTS_TYPE_PT_ADDBITS15;
8044 kern_type = KERN_TYPE_SHA512_SLTPW;
8045 dgst_size = DGST_SIZE_8_8;
8046 parse_func = sha512s_parse_hash;
8047 sort_by_digest = sort_by_digest_8_8;
8048 opti_type = OPTI_TYPE_ZERO_BYTE
8049 | OPTI_TYPE_PRECOMPUTE_INIT
8050 | OPTI_TYPE_PRECOMPUTE_MERKLE
8051 | OPTI_TYPE_EARLY_SKIP
8052 | OPTI_TYPE_NOT_ITERATED
8053 | OPTI_TYPE_PREPENDED_SALT
8054 | OPTI_TYPE_USES_BITS_64
8055 | OPTI_TYPE_RAW_HASH;
8056 dgst_pos0 = 14;
8057 dgst_pos1 = 15;
8058 dgst_pos2 = 6;
8059 dgst_pos3 = 7;
8060 break;
8061
8062 case 1722: hash_type = HASH_TYPE_SHA512;
8063 salt_type = SALT_TYPE_EMBEDDED;
8064 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8065 opts_type = OPTS_TYPE_PT_GENERATE_BE
8066 | OPTS_TYPE_PT_ADD80
8067 | OPTS_TYPE_PT_ADDBITS15
8068 | OPTS_TYPE_ST_HEX;
8069 kern_type = KERN_TYPE_SHA512_SLTPW;
8070 dgst_size = DGST_SIZE_8_8;
8071 parse_func = osx512_parse_hash;
8072 sort_by_digest = sort_by_digest_8_8;
8073 opti_type = OPTI_TYPE_ZERO_BYTE
8074 | OPTI_TYPE_PRECOMPUTE_INIT
8075 | OPTI_TYPE_PRECOMPUTE_MERKLE
8076 | OPTI_TYPE_EARLY_SKIP
8077 | OPTI_TYPE_NOT_ITERATED
8078 | OPTI_TYPE_PREPENDED_SALT
8079 | OPTI_TYPE_USES_BITS_64
8080 | OPTI_TYPE_RAW_HASH;
8081 dgst_pos0 = 14;
8082 dgst_pos1 = 15;
8083 dgst_pos2 = 6;
8084 dgst_pos3 = 7;
8085 break;
8086
8087 case 1730: hash_type = HASH_TYPE_SHA512;
8088 salt_type = SALT_TYPE_INTERN;
8089 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8090 opts_type = OPTS_TYPE_PT_GENERATE_BE
8091 | OPTS_TYPE_PT_UNICODE
8092 | OPTS_TYPE_ST_ADD80
8093 | OPTS_TYPE_ST_ADDBITS15;
8094 kern_type = KERN_TYPE_SHA512_PWSLTU;
8095 dgst_size = DGST_SIZE_8_8;
8096 parse_func = sha512s_parse_hash;
8097 sort_by_digest = sort_by_digest_8_8;
8098 opti_type = OPTI_TYPE_ZERO_BYTE
8099 | OPTI_TYPE_PRECOMPUTE_INIT
8100 | OPTI_TYPE_PRECOMPUTE_MERKLE
8101 | OPTI_TYPE_EARLY_SKIP
8102 | OPTI_TYPE_NOT_ITERATED
8103 | OPTI_TYPE_APPENDED_SALT
8104 | OPTI_TYPE_USES_BITS_64
8105 | OPTI_TYPE_RAW_HASH;
8106 dgst_pos0 = 14;
8107 dgst_pos1 = 15;
8108 dgst_pos2 = 6;
8109 dgst_pos3 = 7;
8110 break;
8111
8112 case 1731: hash_type = HASH_TYPE_SHA512;
8113 salt_type = SALT_TYPE_EMBEDDED;
8114 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8115 opts_type = OPTS_TYPE_PT_GENERATE_BE
8116 | OPTS_TYPE_PT_UNICODE
8117 | OPTS_TYPE_ST_ADD80
8118 | OPTS_TYPE_ST_ADDBITS15
8119 | OPTS_TYPE_ST_HEX;
8120 kern_type = KERN_TYPE_SHA512_PWSLTU;
8121 dgst_size = DGST_SIZE_8_8;
8122 parse_func = mssql2012_parse_hash;
8123 sort_by_digest = sort_by_digest_8_8;
8124 opti_type = OPTI_TYPE_ZERO_BYTE
8125 | OPTI_TYPE_PRECOMPUTE_INIT
8126 | OPTI_TYPE_PRECOMPUTE_MERKLE
8127 | OPTI_TYPE_EARLY_SKIP
8128 | OPTI_TYPE_NOT_ITERATED
8129 | OPTI_TYPE_APPENDED_SALT
8130 | OPTI_TYPE_USES_BITS_64
8131 | OPTI_TYPE_RAW_HASH;
8132 dgst_pos0 = 14;
8133 dgst_pos1 = 15;
8134 dgst_pos2 = 6;
8135 dgst_pos3 = 7;
8136 break;
8137
8138 case 1740: hash_type = HASH_TYPE_SHA512;
8139 salt_type = SALT_TYPE_INTERN;
8140 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8141 opts_type = OPTS_TYPE_PT_GENERATE_BE
8142 | OPTS_TYPE_PT_ADD80
8143 | OPTS_TYPE_PT_ADDBITS15
8144 | OPTS_TYPE_PT_UNICODE;
8145 kern_type = KERN_TYPE_SHA512_SLTPWU;
8146 dgst_size = DGST_SIZE_8_8;
8147 parse_func = sha512s_parse_hash;
8148 sort_by_digest = sort_by_digest_8_8;
8149 opti_type = OPTI_TYPE_ZERO_BYTE
8150 | OPTI_TYPE_PRECOMPUTE_INIT
8151 | OPTI_TYPE_PRECOMPUTE_MERKLE
8152 | OPTI_TYPE_EARLY_SKIP
8153 | OPTI_TYPE_NOT_ITERATED
8154 | OPTI_TYPE_PREPENDED_SALT
8155 | OPTI_TYPE_USES_BITS_64
8156 | OPTI_TYPE_RAW_HASH;
8157 dgst_pos0 = 14;
8158 dgst_pos1 = 15;
8159 dgst_pos2 = 6;
8160 dgst_pos3 = 7;
8161 break;
8162
8163 case 1750: hash_type = HASH_TYPE_SHA512;
8164 salt_type = SALT_TYPE_INTERN;
8165 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8166 opts_type = OPTS_TYPE_PT_GENERATE_BE
8167 | OPTS_TYPE_ST_ADD80;
8168 kern_type = KERN_TYPE_HMACSHA512_PW;
8169 dgst_size = DGST_SIZE_8_8;
8170 parse_func = hmacsha512_parse_hash;
8171 sort_by_digest = sort_by_digest_8_8;
8172 opti_type = OPTI_TYPE_ZERO_BYTE
8173 | OPTI_TYPE_USES_BITS_64
8174 | OPTI_TYPE_NOT_ITERATED;
8175 dgst_pos0 = 14;
8176 dgst_pos1 = 15;
8177 dgst_pos2 = 6;
8178 dgst_pos3 = 7;
8179 break;
8180
8181 case 1760: hash_type = HASH_TYPE_SHA512;
8182 salt_type = SALT_TYPE_INTERN;
8183 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8184 opts_type = OPTS_TYPE_PT_GENERATE_BE
8185 | OPTS_TYPE_PT_ADD80
8186 | OPTS_TYPE_PT_ADDBITS15;
8187 kern_type = KERN_TYPE_HMACSHA512_SLT;
8188 dgst_size = DGST_SIZE_8_8;
8189 parse_func = hmacsha512_parse_hash;
8190 sort_by_digest = sort_by_digest_8_8;
8191 opti_type = OPTI_TYPE_ZERO_BYTE
8192 | OPTI_TYPE_USES_BITS_64
8193 | OPTI_TYPE_NOT_ITERATED;
8194 dgst_pos0 = 14;
8195 dgst_pos1 = 15;
8196 dgst_pos2 = 6;
8197 dgst_pos3 = 7;
8198 break;
8199
8200 case 1800: hash_type = HASH_TYPE_SHA512;
8201 salt_type = SALT_TYPE_EMBEDDED;
8202 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8203 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8204 kern_type = KERN_TYPE_SHA512CRYPT;
8205 dgst_size = DGST_SIZE_8_8;
8206 parse_func = sha512crypt_parse_hash;
8207 sort_by_digest = sort_by_digest_8_8;
8208 opti_type = OPTI_TYPE_ZERO_BYTE
8209 | OPTI_TYPE_USES_BITS_64;
8210 dgst_pos0 = 0;
8211 dgst_pos1 = 1;
8212 dgst_pos2 = 2;
8213 dgst_pos3 = 3;
8214 break;
8215
8216 case 2100: hash_type = HASH_TYPE_DCC2;
8217 salt_type = SALT_TYPE_EMBEDDED;
8218 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8219 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8220 | OPTS_TYPE_ST_LOWER
8221 | OPTS_TYPE_ST_UNICODE;
8222 kern_type = KERN_TYPE_DCC2;
8223 dgst_size = DGST_SIZE_4_4;
8224 parse_func = dcc2_parse_hash;
8225 sort_by_digest = sort_by_digest_4_4;
8226 opti_type = OPTI_TYPE_ZERO_BYTE;
8227 dgst_pos0 = 0;
8228 dgst_pos1 = 1;
8229 dgst_pos2 = 2;
8230 dgst_pos3 = 3;
8231 break;
8232
8233 case 2400: hash_type = HASH_TYPE_MD5;
8234 salt_type = SALT_TYPE_NONE;
8235 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8236 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8237 kern_type = KERN_TYPE_MD5PIX;
8238 dgst_size = DGST_SIZE_4_4;
8239 parse_func = md5pix_parse_hash;
8240 sort_by_digest = sort_by_digest_4_4;
8241 opti_type = OPTI_TYPE_ZERO_BYTE
8242 | OPTI_TYPE_PRECOMPUTE_INIT
8243 | OPTI_TYPE_PRECOMPUTE_MERKLE
8244 | OPTI_TYPE_EARLY_SKIP
8245 | OPTI_TYPE_NOT_ITERATED
8246 | OPTI_TYPE_NOT_SALTED;
8247 dgst_pos0 = 0;
8248 dgst_pos1 = 3;
8249 dgst_pos2 = 2;
8250 dgst_pos3 = 1;
8251 break;
8252
8253 case 2410: hash_type = HASH_TYPE_MD5;
8254 salt_type = SALT_TYPE_INTERN;
8255 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8256 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8257 kern_type = KERN_TYPE_MD5ASA;
8258 dgst_size = DGST_SIZE_4_4;
8259 parse_func = md5asa_parse_hash;
8260 sort_by_digest = sort_by_digest_4_4;
8261 opti_type = OPTI_TYPE_ZERO_BYTE
8262 | OPTI_TYPE_PRECOMPUTE_INIT
8263 | OPTI_TYPE_PRECOMPUTE_MERKLE
8264 | OPTI_TYPE_EARLY_SKIP
8265 | OPTI_TYPE_NOT_ITERATED;
8266 dgst_pos0 = 0;
8267 dgst_pos1 = 3;
8268 dgst_pos2 = 2;
8269 dgst_pos3 = 1;
8270 break;
8271
8272 case 2500: hash_type = HASH_TYPE_WPA;
8273 salt_type = SALT_TYPE_EMBEDDED;
8274 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8275 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8276 kern_type = KERN_TYPE_WPA;
8277 dgst_size = DGST_SIZE_4_4;
8278 parse_func = wpa_parse_hash;
8279 sort_by_digest = sort_by_digest_4_4;
8280 opti_type = OPTI_TYPE_ZERO_BYTE;
8281 dgst_pos0 = 0;
8282 dgst_pos1 = 1;
8283 dgst_pos2 = 2;
8284 dgst_pos3 = 3;
8285 break;
8286
8287 case 2600: hash_type = HASH_TYPE_MD5;
8288 salt_type = SALT_TYPE_VIRTUAL;
8289 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8290 opts_type = OPTS_TYPE_PT_GENERATE_LE
8291 | OPTS_TYPE_PT_ADD80
8292 | OPTS_TYPE_PT_ADDBITS14
8293 | OPTS_TYPE_ST_ADD80;
8294 kern_type = KERN_TYPE_MD55_PWSLT1;
8295 dgst_size = DGST_SIZE_4_4;
8296 parse_func = md5md5_parse_hash;
8297 sort_by_digest = sort_by_digest_4_4;
8298 opti_type = OPTI_TYPE_ZERO_BYTE
8299 | OPTI_TYPE_PRECOMPUTE_INIT
8300 | OPTI_TYPE_PRECOMPUTE_MERKLE
8301 | OPTI_TYPE_EARLY_SKIP;
8302 dgst_pos0 = 0;
8303 dgst_pos1 = 3;
8304 dgst_pos2 = 2;
8305 dgst_pos3 = 1;
8306 break;
8307
8308 case 2611: hash_type = HASH_TYPE_MD5;
8309 salt_type = SALT_TYPE_INTERN;
8310 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8311 opts_type = OPTS_TYPE_PT_GENERATE_LE
8312 | OPTS_TYPE_PT_ADD80
8313 | OPTS_TYPE_PT_ADDBITS14
8314 | OPTS_TYPE_ST_ADD80;
8315 kern_type = KERN_TYPE_MD55_PWSLT1;
8316 dgst_size = DGST_SIZE_4_4;
8317 parse_func = vb3_parse_hash;
8318 sort_by_digest = sort_by_digest_4_4;
8319 opti_type = OPTI_TYPE_ZERO_BYTE
8320 | OPTI_TYPE_PRECOMPUTE_INIT
8321 | OPTI_TYPE_PRECOMPUTE_MERKLE
8322 | OPTI_TYPE_EARLY_SKIP;
8323 dgst_pos0 = 0;
8324 dgst_pos1 = 3;
8325 dgst_pos2 = 2;
8326 dgst_pos3 = 1;
8327 break;
8328
8329 case 2612: hash_type = HASH_TYPE_MD5;
8330 salt_type = SALT_TYPE_EMBEDDED;
8331 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8332 opts_type = OPTS_TYPE_PT_GENERATE_LE
8333 | OPTS_TYPE_PT_ADD80
8334 | OPTS_TYPE_PT_ADDBITS14
8335 | OPTS_TYPE_ST_ADD80
8336 | OPTS_TYPE_ST_HEX;
8337 kern_type = KERN_TYPE_MD55_PWSLT1;
8338 dgst_size = DGST_SIZE_4_4;
8339 parse_func = phps_parse_hash;
8340 sort_by_digest = sort_by_digest_4_4;
8341 opti_type = OPTI_TYPE_ZERO_BYTE
8342 | OPTI_TYPE_PRECOMPUTE_INIT
8343 | OPTI_TYPE_PRECOMPUTE_MERKLE
8344 | OPTI_TYPE_EARLY_SKIP;
8345 dgst_pos0 = 0;
8346 dgst_pos1 = 3;
8347 dgst_pos2 = 2;
8348 dgst_pos3 = 1;
8349 break;
8350
8351 case 2711: hash_type = HASH_TYPE_MD5;
8352 salt_type = SALT_TYPE_INTERN;
8353 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8354 opts_type = OPTS_TYPE_PT_GENERATE_LE
8355 | OPTS_TYPE_PT_ADD80
8356 | OPTS_TYPE_PT_ADDBITS14
8357 | OPTS_TYPE_ST_ADD80;
8358 kern_type = KERN_TYPE_MD55_PWSLT2;
8359 dgst_size = DGST_SIZE_4_4;
8360 parse_func = vb30_parse_hash;
8361 sort_by_digest = sort_by_digest_4_4;
8362 opti_type = OPTI_TYPE_ZERO_BYTE
8363 | OPTI_TYPE_PRECOMPUTE_INIT
8364 | OPTI_TYPE_EARLY_SKIP;
8365 dgst_pos0 = 0;
8366 dgst_pos1 = 3;
8367 dgst_pos2 = 2;
8368 dgst_pos3 = 1;
8369 break;
8370
8371 case 2811: hash_type = HASH_TYPE_MD5;
8372 salt_type = SALT_TYPE_INTERN;
8373 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8374 opts_type = OPTS_TYPE_PT_GENERATE_LE
8375 | OPTS_TYPE_PT_ADD80
8376 | OPTS_TYPE_PT_ADDBITS14;
8377 kern_type = KERN_TYPE_MD55_SLTPW;
8378 dgst_size = DGST_SIZE_4_4;
8379 parse_func = ipb2_parse_hash;
8380 sort_by_digest = sort_by_digest_4_4;
8381 opti_type = OPTI_TYPE_ZERO_BYTE
8382 | OPTI_TYPE_PRECOMPUTE_INIT
8383 | OPTI_TYPE_EARLY_SKIP;
8384 dgst_pos0 = 0;
8385 dgst_pos1 = 3;
8386 dgst_pos2 = 2;
8387 dgst_pos3 = 1;
8388 break;
8389
8390 case 3000: hash_type = HASH_TYPE_LM;
8391 salt_type = SALT_TYPE_NONE;
8392 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8393 opts_type = OPTS_TYPE_PT_GENERATE_LE
8394 | OPTS_TYPE_PT_UPPER
8395 | OPTS_TYPE_PT_BITSLICE;
8396 kern_type = KERN_TYPE_LM;
8397 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8398 parse_func = lm_parse_hash;
8399 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8400 opti_type = OPTI_TYPE_ZERO_BYTE
8401 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8402 dgst_pos0 = 0;
8403 dgst_pos1 = 1;
8404 dgst_pos2 = 2;
8405 dgst_pos3 = 3;
8406 break;
8407
8408 case 3100: hash_type = HASH_TYPE_ORACLEH;
8409 salt_type = SALT_TYPE_INTERN;
8410 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8411 opts_type = OPTS_TYPE_PT_GENERATE_LE
8412 | OPTS_TYPE_PT_UPPER
8413 | OPTS_TYPE_ST_UPPER;
8414 kern_type = KERN_TYPE_ORACLEH;
8415 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8416 parse_func = oracleh_parse_hash;
8417 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8418 opti_type = OPTI_TYPE_ZERO_BYTE;
8419 dgst_pos0 = 0;
8420 dgst_pos1 = 1;
8421 dgst_pos2 = 2;
8422 dgst_pos3 = 3;
8423 break;
8424
8425 case 3200: hash_type = HASH_TYPE_BCRYPT;
8426 salt_type = SALT_TYPE_EMBEDDED;
8427 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8428 opts_type = OPTS_TYPE_PT_GENERATE_LE
8429 | OPTS_TYPE_ST_GENERATE_LE;
8430 kern_type = KERN_TYPE_BCRYPT;
8431 dgst_size = DGST_SIZE_4_6;
8432 parse_func = bcrypt_parse_hash;
8433 sort_by_digest = sort_by_digest_4_6;
8434 opti_type = OPTI_TYPE_ZERO_BYTE;
8435 dgst_pos0 = 0;
8436 dgst_pos1 = 1;
8437 dgst_pos2 = 2;
8438 dgst_pos3 = 3;
8439 break;
8440
8441 case 3710: hash_type = HASH_TYPE_MD5;
8442 salt_type = SALT_TYPE_INTERN;
8443 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8444 opts_type = OPTS_TYPE_PT_GENERATE_LE
8445 | OPTS_TYPE_PT_ADD80
8446 | OPTS_TYPE_PT_ADDBITS14;
8447 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8448 dgst_size = DGST_SIZE_4_4;
8449 parse_func = md5s_parse_hash;
8450 sort_by_digest = sort_by_digest_4_4;
8451 opti_type = OPTI_TYPE_ZERO_BYTE
8452 | OPTI_TYPE_PRECOMPUTE_INIT
8453 | OPTI_TYPE_PRECOMPUTE_MERKLE
8454 | OPTI_TYPE_EARLY_SKIP;
8455 dgst_pos0 = 0;
8456 dgst_pos1 = 3;
8457 dgst_pos2 = 2;
8458 dgst_pos3 = 1;
8459 break;
8460
8461 case 3711: hash_type = HASH_TYPE_MD5;
8462 salt_type = SALT_TYPE_EMBEDDED;
8463 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8464 opts_type = OPTS_TYPE_PT_GENERATE_LE
8465 | OPTS_TYPE_PT_ADD80
8466 | OPTS_TYPE_PT_ADDBITS14;
8467 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8468 dgst_size = DGST_SIZE_4_4;
8469 parse_func = mediawiki_b_parse_hash;
8470 sort_by_digest = sort_by_digest_4_4;
8471 opti_type = OPTI_TYPE_ZERO_BYTE
8472 | OPTI_TYPE_PRECOMPUTE_INIT
8473 | OPTI_TYPE_PRECOMPUTE_MERKLE
8474 | OPTI_TYPE_EARLY_SKIP;
8475 dgst_pos0 = 0;
8476 dgst_pos1 = 3;
8477 dgst_pos2 = 2;
8478 dgst_pos3 = 1;
8479 break;
8480
8481 case 3800: hash_type = HASH_TYPE_MD5;
8482 salt_type = SALT_TYPE_INTERN;
8483 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8484 opts_type = OPTS_TYPE_PT_GENERATE_LE
8485 | OPTS_TYPE_ST_ADDBITS14;
8486 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8487 dgst_size = DGST_SIZE_4_4;
8488 parse_func = md5s_parse_hash;
8489 sort_by_digest = sort_by_digest_4_4;
8490 opti_type = OPTI_TYPE_ZERO_BYTE
8491 | OPTI_TYPE_PRECOMPUTE_INIT
8492 | OPTI_TYPE_PRECOMPUTE_MERKLE
8493 | OPTI_TYPE_EARLY_SKIP
8494 | OPTI_TYPE_NOT_ITERATED
8495 | OPTI_TYPE_RAW_HASH;
8496 dgst_pos0 = 0;
8497 dgst_pos1 = 3;
8498 dgst_pos2 = 2;
8499 dgst_pos3 = 1;
8500 break;
8501
8502 case 4300: hash_type = HASH_TYPE_MD5;
8503 salt_type = SALT_TYPE_VIRTUAL;
8504 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8505 opts_type = OPTS_TYPE_PT_GENERATE_LE
8506 | OPTS_TYPE_PT_ADD80
8507 | OPTS_TYPE_PT_ADDBITS14
8508 | OPTS_TYPE_ST_ADD80;
8509 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8510 dgst_size = DGST_SIZE_4_4;
8511 parse_func = md5md5_parse_hash;
8512 sort_by_digest = sort_by_digest_4_4;
8513 opti_type = OPTI_TYPE_ZERO_BYTE
8514 | OPTI_TYPE_PRECOMPUTE_INIT
8515 | OPTI_TYPE_PRECOMPUTE_MERKLE
8516 | OPTI_TYPE_EARLY_SKIP;
8517 dgst_pos0 = 0;
8518 dgst_pos1 = 3;
8519 dgst_pos2 = 2;
8520 dgst_pos3 = 1;
8521 break;
8522
8523
8524 case 4400: hash_type = HASH_TYPE_MD5;
8525 salt_type = SALT_TYPE_NONE;
8526 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8527 opts_type = OPTS_TYPE_PT_GENERATE_BE
8528 | OPTS_TYPE_PT_ADD80
8529 | OPTS_TYPE_PT_ADDBITS15;
8530 kern_type = KERN_TYPE_MD5_SHA1;
8531 dgst_size = DGST_SIZE_4_4;
8532 parse_func = md5_parse_hash;
8533 sort_by_digest = sort_by_digest_4_4;
8534 opti_type = OPTI_TYPE_ZERO_BYTE
8535 | OPTI_TYPE_PRECOMPUTE_INIT
8536 | OPTI_TYPE_PRECOMPUTE_MERKLE
8537 | OPTI_TYPE_EARLY_SKIP
8538 | OPTI_TYPE_NOT_ITERATED
8539 | OPTI_TYPE_NOT_SALTED
8540 | OPTI_TYPE_RAW_HASH;
8541 dgst_pos0 = 0;
8542 dgst_pos1 = 3;
8543 dgst_pos2 = 2;
8544 dgst_pos3 = 1;
8545 break;
8546
8547 case 4500: hash_type = HASH_TYPE_SHA1;
8548 salt_type = SALT_TYPE_NONE;
8549 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8550 opts_type = OPTS_TYPE_PT_GENERATE_BE
8551 | OPTS_TYPE_PT_ADD80
8552 | OPTS_TYPE_PT_ADDBITS15;
8553 kern_type = KERN_TYPE_SHA11;
8554 dgst_size = DGST_SIZE_4_5;
8555 parse_func = sha1_parse_hash;
8556 sort_by_digest = sort_by_digest_4_5;
8557 opti_type = OPTI_TYPE_ZERO_BYTE
8558 | OPTI_TYPE_PRECOMPUTE_INIT
8559 | OPTI_TYPE_PRECOMPUTE_MERKLE
8560 | OPTI_TYPE_EARLY_SKIP
8561 | OPTI_TYPE_NOT_SALTED;
8562 dgst_pos0 = 3;
8563 dgst_pos1 = 4;
8564 dgst_pos2 = 2;
8565 dgst_pos3 = 1;
8566 break;
8567
8568 case 4700: hash_type = HASH_TYPE_SHA1;
8569 salt_type = SALT_TYPE_NONE;
8570 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8571 opts_type = OPTS_TYPE_PT_GENERATE_LE
8572 | OPTS_TYPE_PT_ADD80
8573 | OPTS_TYPE_PT_ADDBITS14;
8574 kern_type = KERN_TYPE_SHA1_MD5;
8575 dgst_size = DGST_SIZE_4_5;
8576 parse_func = sha1_parse_hash;
8577 sort_by_digest = sort_by_digest_4_5;
8578 opti_type = OPTI_TYPE_ZERO_BYTE
8579 | OPTI_TYPE_PRECOMPUTE_INIT
8580 | OPTI_TYPE_PRECOMPUTE_MERKLE
8581 | OPTI_TYPE_EARLY_SKIP
8582 | OPTI_TYPE_NOT_ITERATED
8583 | OPTI_TYPE_NOT_SALTED
8584 | OPTI_TYPE_RAW_HASH;
8585 dgst_pos0 = 3;
8586 dgst_pos1 = 4;
8587 dgst_pos2 = 2;
8588 dgst_pos3 = 1;
8589 break;
8590
8591 case 4800: hash_type = HASH_TYPE_MD5;
8592 salt_type = SALT_TYPE_EMBEDDED;
8593 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8594 opts_type = OPTS_TYPE_PT_GENERATE_LE
8595 | OPTS_TYPE_PT_ADDBITS14;
8596 kern_type = KERN_TYPE_MD5_CHAP;
8597 dgst_size = DGST_SIZE_4_4;
8598 parse_func = chap_parse_hash;
8599 sort_by_digest = sort_by_digest_4_4;
8600 opti_type = OPTI_TYPE_ZERO_BYTE
8601 | OPTI_TYPE_PRECOMPUTE_INIT
8602 | OPTI_TYPE_PRECOMPUTE_MERKLE
8603 | OPTI_TYPE_MEET_IN_MIDDLE
8604 | OPTI_TYPE_EARLY_SKIP
8605 | OPTI_TYPE_NOT_ITERATED
8606 | OPTI_TYPE_RAW_HASH;
8607 dgst_pos0 = 0;
8608 dgst_pos1 = 3;
8609 dgst_pos2 = 2;
8610 dgst_pos3 = 1;
8611 break;
8612
8613 case 4900: hash_type = HASH_TYPE_SHA1;
8614 salt_type = SALT_TYPE_INTERN;
8615 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8616 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8617 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8618 dgst_size = DGST_SIZE_4_5;
8619 parse_func = sha1s_parse_hash;
8620 sort_by_digest = sort_by_digest_4_5;
8621 opti_type = OPTI_TYPE_ZERO_BYTE
8622 | OPTI_TYPE_PRECOMPUTE_INIT
8623 | OPTI_TYPE_PRECOMPUTE_MERKLE
8624 | OPTI_TYPE_EARLY_SKIP;
8625 dgst_pos0 = 3;
8626 dgst_pos1 = 4;
8627 dgst_pos2 = 2;
8628 dgst_pos3 = 1;
8629 break;
8630
8631 case 5000: hash_type = HASH_TYPE_KECCAK;
8632 salt_type = SALT_TYPE_EMBEDDED;
8633 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8634 opts_type = OPTS_TYPE_PT_GENERATE_LE
8635 | OPTS_TYPE_PT_ADD01;
8636 kern_type = KERN_TYPE_KECCAK;
8637 dgst_size = DGST_SIZE_8_25;
8638 parse_func = keccak_parse_hash;
8639 sort_by_digest = sort_by_digest_8_25;
8640 opti_type = OPTI_TYPE_ZERO_BYTE
8641 | OPTI_TYPE_USES_BITS_64
8642 | OPTI_TYPE_RAW_HASH;
8643 dgst_pos0 = 2;
8644 dgst_pos1 = 3;
8645 dgst_pos2 = 4;
8646 dgst_pos3 = 5;
8647 break;
8648
8649 case 5100: hash_type = HASH_TYPE_MD5H;
8650 salt_type = SALT_TYPE_NONE;
8651 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8652 opts_type = OPTS_TYPE_PT_GENERATE_LE
8653 | OPTS_TYPE_PT_ADD80
8654 | OPTS_TYPE_PT_ADDBITS14;
8655 kern_type = KERN_TYPE_MD5H;
8656 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8657 parse_func = md5half_parse_hash;
8658 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8659 opti_type = OPTI_TYPE_ZERO_BYTE
8660 | OPTI_TYPE_RAW_HASH;
8661 dgst_pos0 = 0;
8662 dgst_pos1 = 1;
8663 dgst_pos2 = 2;
8664 dgst_pos3 = 3;
8665 break;
8666
8667 case 5200: hash_type = HASH_TYPE_SHA256;
8668 salt_type = SALT_TYPE_EMBEDDED;
8669 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8670 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8671 kern_type = KERN_TYPE_PSAFE3;
8672 dgst_size = DGST_SIZE_4_8;
8673 parse_func = psafe3_parse_hash;
8674 sort_by_digest = sort_by_digest_4_8;
8675 opti_type = OPTI_TYPE_ZERO_BYTE;
8676 dgst_pos0 = 0;
8677 dgst_pos1 = 1;
8678 dgst_pos2 = 2;
8679 dgst_pos3 = 3;
8680 break;
8681
8682 case 5300: hash_type = HASH_TYPE_MD5;
8683 salt_type = SALT_TYPE_EMBEDDED;
8684 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8685 opts_type = OPTS_TYPE_PT_GENERATE_LE
8686 | OPTS_TYPE_ST_ADD80;
8687 kern_type = KERN_TYPE_IKEPSK_MD5;
8688 dgst_size = DGST_SIZE_4_4;
8689 parse_func = ikepsk_md5_parse_hash;
8690 sort_by_digest = sort_by_digest_4_4;
8691 opti_type = OPTI_TYPE_ZERO_BYTE;
8692 dgst_pos0 = 0;
8693 dgst_pos1 = 3;
8694 dgst_pos2 = 2;
8695 dgst_pos3 = 1;
8696 break;
8697
8698 case 5400: hash_type = HASH_TYPE_SHA1;
8699 salt_type = SALT_TYPE_EMBEDDED;
8700 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8701 opts_type = OPTS_TYPE_PT_GENERATE_BE
8702 | OPTS_TYPE_ST_ADD80;
8703 kern_type = KERN_TYPE_IKEPSK_SHA1;
8704 dgst_size = DGST_SIZE_4_5;
8705 parse_func = ikepsk_sha1_parse_hash;
8706 sort_by_digest = sort_by_digest_4_5;
8707 opti_type = OPTI_TYPE_ZERO_BYTE;
8708 dgst_pos0 = 3;
8709 dgst_pos1 = 4;
8710 dgst_pos2 = 2;
8711 dgst_pos3 = 1;
8712 break;
8713
8714 case 5500: hash_type = HASH_TYPE_NETNTLM;
8715 salt_type = SALT_TYPE_EMBEDDED;
8716 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8717 opts_type = OPTS_TYPE_PT_GENERATE_LE
8718 | OPTS_TYPE_PT_ADD80
8719 | OPTS_TYPE_PT_ADDBITS14
8720 | OPTS_TYPE_PT_UNICODE
8721 | OPTS_TYPE_ST_HEX;
8722 kern_type = KERN_TYPE_NETNTLMv1;
8723 dgst_size = DGST_SIZE_4_4;
8724 parse_func = netntlmv1_parse_hash;
8725 sort_by_digest = sort_by_digest_4_4;
8726 opti_type = OPTI_TYPE_ZERO_BYTE
8727 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8728 dgst_pos0 = 0;
8729 dgst_pos1 = 1;
8730 dgst_pos2 = 2;
8731 dgst_pos3 = 3;
8732 break;
8733
8734 case 5600: hash_type = HASH_TYPE_MD5;
8735 salt_type = SALT_TYPE_EMBEDDED;
8736 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8737 opts_type = OPTS_TYPE_PT_GENERATE_LE
8738 | OPTS_TYPE_PT_ADD80
8739 | OPTS_TYPE_PT_ADDBITS14
8740 | OPTS_TYPE_PT_UNICODE;
8741 kern_type = KERN_TYPE_NETNTLMv2;
8742 dgst_size = DGST_SIZE_4_4;
8743 parse_func = netntlmv2_parse_hash;
8744 sort_by_digest = sort_by_digest_4_4;
8745 opti_type = OPTI_TYPE_ZERO_BYTE;
8746 dgst_pos0 = 0;
8747 dgst_pos1 = 3;
8748 dgst_pos2 = 2;
8749 dgst_pos3 = 1;
8750 break;
8751
8752 case 5700: hash_type = HASH_TYPE_SHA256;
8753 salt_type = SALT_TYPE_NONE;
8754 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8755 opts_type = OPTS_TYPE_PT_GENERATE_BE
8756 | OPTS_TYPE_PT_ADD80
8757 | OPTS_TYPE_PT_ADDBITS15;
8758 kern_type = KERN_TYPE_SHA256;
8759 dgst_size = DGST_SIZE_4_8;
8760 parse_func = cisco4_parse_hash;
8761 sort_by_digest = sort_by_digest_4_8;
8762 opti_type = OPTI_TYPE_ZERO_BYTE
8763 | OPTI_TYPE_PRECOMPUTE_INIT
8764 | OPTI_TYPE_PRECOMPUTE_MERKLE
8765 | OPTI_TYPE_EARLY_SKIP
8766 | OPTI_TYPE_NOT_ITERATED
8767 | OPTI_TYPE_NOT_SALTED
8768 | OPTI_TYPE_RAW_HASH;
8769 dgst_pos0 = 3;
8770 dgst_pos1 = 7;
8771 dgst_pos2 = 2;
8772 dgst_pos3 = 6;
8773 break;
8774
8775 case 5800: hash_type = HASH_TYPE_SHA1;
8776 salt_type = SALT_TYPE_INTERN;
8777 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8778 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8779 | OPTS_TYPE_ST_ADD80;
8780 kern_type = KERN_TYPE_ANDROIDPIN;
8781 dgst_size = DGST_SIZE_4_5;
8782 parse_func = androidpin_parse_hash;
8783 sort_by_digest = sort_by_digest_4_5;
8784 opti_type = OPTI_TYPE_ZERO_BYTE;
8785 dgst_pos0 = 0;
8786 dgst_pos1 = 1;
8787 dgst_pos2 = 2;
8788 dgst_pos3 = 3;
8789 break;
8790
8791 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8792 salt_type = SALT_TYPE_NONE;
8793 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8794 opts_type = OPTS_TYPE_PT_GENERATE_LE
8795 | OPTS_TYPE_PT_ADD80;
8796 kern_type = KERN_TYPE_RIPEMD160;
8797 dgst_size = DGST_SIZE_4_5;
8798 parse_func = ripemd160_parse_hash;
8799 sort_by_digest = sort_by_digest_4_5;
8800 opti_type = OPTI_TYPE_ZERO_BYTE;
8801 dgst_pos0 = 0;
8802 dgst_pos1 = 1;
8803 dgst_pos2 = 2;
8804 dgst_pos3 = 3;
8805 break;
8806
8807 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8808 salt_type = SALT_TYPE_NONE;
8809 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8810 opts_type = OPTS_TYPE_PT_GENERATE_BE
8811 | OPTS_TYPE_PT_ADD80;
8812 kern_type = KERN_TYPE_WHIRLPOOL;
8813 dgst_size = DGST_SIZE_4_16;
8814 parse_func = whirlpool_parse_hash;
8815 sort_by_digest = sort_by_digest_4_16;
8816 opti_type = OPTI_TYPE_ZERO_BYTE;
8817 dgst_pos0 = 0;
8818 dgst_pos1 = 1;
8819 dgst_pos2 = 2;
8820 dgst_pos3 = 3;
8821 break;
8822
8823 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8824 salt_type = SALT_TYPE_EMBEDDED;
8825 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8826 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8827 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8828 dgst_size = DGST_SIZE_4_5;
8829 parse_func = truecrypt_parse_hash_2k;
8830 sort_by_digest = sort_by_digest_4_5;
8831 opti_type = OPTI_TYPE_ZERO_BYTE;
8832 dgst_pos0 = 0;
8833 dgst_pos1 = 1;
8834 dgst_pos2 = 2;
8835 dgst_pos3 = 3;
8836 break;
8837
8838 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8839 salt_type = SALT_TYPE_EMBEDDED;
8840 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8841 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8842 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8843 dgst_size = DGST_SIZE_4_5;
8844 parse_func = truecrypt_parse_hash_2k;
8845 sort_by_digest = sort_by_digest_4_5;
8846 opti_type = OPTI_TYPE_ZERO_BYTE;
8847 dgst_pos0 = 0;
8848 dgst_pos1 = 1;
8849 dgst_pos2 = 2;
8850 dgst_pos3 = 3;
8851 break;
8852
8853 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8854 salt_type = SALT_TYPE_EMBEDDED;
8855 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8856 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8857 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8858 dgst_size = DGST_SIZE_4_5;
8859 parse_func = truecrypt_parse_hash_2k;
8860 sort_by_digest = sort_by_digest_4_5;
8861 opti_type = OPTI_TYPE_ZERO_BYTE;
8862 dgst_pos0 = 0;
8863 dgst_pos1 = 1;
8864 dgst_pos2 = 2;
8865 dgst_pos3 = 3;
8866 break;
8867
8868 case 6221: hash_type = HASH_TYPE_SHA512;
8869 salt_type = SALT_TYPE_EMBEDDED;
8870 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8871 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8872 kern_type = KERN_TYPE_TCSHA512_XTS512;
8873 dgst_size = DGST_SIZE_8_8;
8874 parse_func = truecrypt_parse_hash_1k;
8875 sort_by_digest = sort_by_digest_8_8;
8876 opti_type = OPTI_TYPE_ZERO_BYTE
8877 | OPTI_TYPE_USES_BITS_64;
8878 dgst_pos0 = 0;
8879 dgst_pos1 = 1;
8880 dgst_pos2 = 2;
8881 dgst_pos3 = 3;
8882 break;
8883
8884 case 6222: hash_type = HASH_TYPE_SHA512;
8885 salt_type = SALT_TYPE_EMBEDDED;
8886 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8887 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8888 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8889 dgst_size = DGST_SIZE_8_8;
8890 parse_func = truecrypt_parse_hash_1k;
8891 sort_by_digest = sort_by_digest_8_8;
8892 opti_type = OPTI_TYPE_ZERO_BYTE
8893 | OPTI_TYPE_USES_BITS_64;
8894 dgst_pos0 = 0;
8895 dgst_pos1 = 1;
8896 dgst_pos2 = 2;
8897 dgst_pos3 = 3;
8898 break;
8899
8900 case 6223: hash_type = HASH_TYPE_SHA512;
8901 salt_type = SALT_TYPE_EMBEDDED;
8902 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8903 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8904 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8905 dgst_size = DGST_SIZE_8_8;
8906 parse_func = truecrypt_parse_hash_1k;
8907 sort_by_digest = sort_by_digest_8_8;
8908 opti_type = OPTI_TYPE_ZERO_BYTE
8909 | OPTI_TYPE_USES_BITS_64;
8910 dgst_pos0 = 0;
8911 dgst_pos1 = 1;
8912 dgst_pos2 = 2;
8913 dgst_pos3 = 3;
8914 break;
8915
8916 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8917 salt_type = SALT_TYPE_EMBEDDED;
8918 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8919 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8920 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8921 dgst_size = DGST_SIZE_4_8;
8922 parse_func = truecrypt_parse_hash_1k;
8923 sort_by_digest = sort_by_digest_4_8;
8924 opti_type = OPTI_TYPE_ZERO_BYTE;
8925 dgst_pos0 = 0;
8926 dgst_pos1 = 1;
8927 dgst_pos2 = 2;
8928 dgst_pos3 = 3;
8929 break;
8930
8931 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8932 salt_type = SALT_TYPE_EMBEDDED;
8933 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8934 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8935 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8936 dgst_size = DGST_SIZE_4_8;
8937 parse_func = truecrypt_parse_hash_1k;
8938 sort_by_digest = sort_by_digest_4_8;
8939 opti_type = OPTI_TYPE_ZERO_BYTE;
8940 dgst_pos0 = 0;
8941 dgst_pos1 = 1;
8942 dgst_pos2 = 2;
8943 dgst_pos3 = 3;
8944 break;
8945
8946 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8947 salt_type = SALT_TYPE_EMBEDDED;
8948 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8949 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8950 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8951 dgst_size = DGST_SIZE_4_8;
8952 parse_func = truecrypt_parse_hash_1k;
8953 sort_by_digest = sort_by_digest_4_8;
8954 opti_type = OPTI_TYPE_ZERO_BYTE;
8955 dgst_pos0 = 0;
8956 dgst_pos1 = 1;
8957 dgst_pos2 = 2;
8958 dgst_pos3 = 3;
8959 break;
8960
8961 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8962 salt_type = SALT_TYPE_EMBEDDED;
8963 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8964 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8965 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8966 dgst_size = DGST_SIZE_4_5;
8967 parse_func = truecrypt_parse_hash_1k;
8968 sort_by_digest = sort_by_digest_4_5;
8969 opti_type = OPTI_TYPE_ZERO_BYTE;
8970 dgst_pos0 = 0;
8971 dgst_pos1 = 1;
8972 dgst_pos2 = 2;
8973 dgst_pos3 = 3;
8974 break;
8975
8976 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8977 salt_type = SALT_TYPE_EMBEDDED;
8978 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8979 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8980 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8981 dgst_size = DGST_SIZE_4_5;
8982 parse_func = truecrypt_parse_hash_1k;
8983 sort_by_digest = sort_by_digest_4_5;
8984 opti_type = OPTI_TYPE_ZERO_BYTE;
8985 dgst_pos0 = 0;
8986 dgst_pos1 = 1;
8987 dgst_pos2 = 2;
8988 dgst_pos3 = 3;
8989 break;
8990
8991 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8992 salt_type = SALT_TYPE_EMBEDDED;
8993 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8994 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8995 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8996 dgst_size = DGST_SIZE_4_5;
8997 parse_func = truecrypt_parse_hash_1k;
8998 sort_by_digest = sort_by_digest_4_5;
8999 opti_type = OPTI_TYPE_ZERO_BYTE;
9000 dgst_pos0 = 0;
9001 dgst_pos1 = 1;
9002 dgst_pos2 = 2;
9003 dgst_pos3 = 3;
9004 break;
9005
9006 case 6300: hash_type = HASH_TYPE_MD5;
9007 salt_type = SALT_TYPE_EMBEDDED;
9008 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9009 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9010 kern_type = KERN_TYPE_MD5AIX;
9011 dgst_size = DGST_SIZE_4_4;
9012 parse_func = md5aix_parse_hash;
9013 sort_by_digest = sort_by_digest_4_4;
9014 opti_type = OPTI_TYPE_ZERO_BYTE;
9015 dgst_pos0 = 0;
9016 dgst_pos1 = 1;
9017 dgst_pos2 = 2;
9018 dgst_pos3 = 3;
9019 break;
9020
9021 case 6400: hash_type = HASH_TYPE_SHA256;
9022 salt_type = SALT_TYPE_EMBEDDED;
9023 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9024 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9025 kern_type = KERN_TYPE_SHA256AIX;
9026 dgst_size = DGST_SIZE_4_8;
9027 parse_func = sha256aix_parse_hash;
9028 sort_by_digest = sort_by_digest_4_8;
9029 opti_type = OPTI_TYPE_ZERO_BYTE;
9030 dgst_pos0 = 0;
9031 dgst_pos1 = 1;
9032 dgst_pos2 = 2;
9033 dgst_pos3 = 3;
9034 break;
9035
9036 case 6500: hash_type = HASH_TYPE_SHA512;
9037 salt_type = SALT_TYPE_EMBEDDED;
9038 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9039 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9040 kern_type = KERN_TYPE_SHA512AIX;
9041 dgst_size = DGST_SIZE_8_8;
9042 parse_func = sha512aix_parse_hash;
9043 sort_by_digest = sort_by_digest_8_8;
9044 opti_type = OPTI_TYPE_ZERO_BYTE
9045 | OPTI_TYPE_USES_BITS_64;
9046 dgst_pos0 = 0;
9047 dgst_pos1 = 1;
9048 dgst_pos2 = 2;
9049 dgst_pos3 = 3;
9050 break;
9051
9052 case 6600: hash_type = HASH_TYPE_AES;
9053 salt_type = SALT_TYPE_EMBEDDED;
9054 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9055 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9056 kern_type = KERN_TYPE_AGILEKEY;
9057 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9058 parse_func = agilekey_parse_hash;
9059 sort_by_digest = sort_by_digest_4_5;
9060 opti_type = OPTI_TYPE_ZERO_BYTE;
9061 dgst_pos0 = 0;
9062 dgst_pos1 = 1;
9063 dgst_pos2 = 2;
9064 dgst_pos3 = 3;
9065 break;
9066
9067 case 6700: hash_type = HASH_TYPE_SHA1;
9068 salt_type = SALT_TYPE_EMBEDDED;
9069 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9070 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9071 kern_type = KERN_TYPE_SHA1AIX;
9072 dgst_size = DGST_SIZE_4_5;
9073 parse_func = sha1aix_parse_hash;
9074 sort_by_digest = sort_by_digest_4_5;
9075 opti_type = OPTI_TYPE_ZERO_BYTE;
9076 dgst_pos0 = 0;
9077 dgst_pos1 = 1;
9078 dgst_pos2 = 2;
9079 dgst_pos3 = 3;
9080 break;
9081
9082 case 6800: hash_type = HASH_TYPE_AES;
9083 salt_type = SALT_TYPE_EMBEDDED;
9084 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9085 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9086 kern_type = KERN_TYPE_LASTPASS;
9087 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9088 parse_func = lastpass_parse_hash;
9089 sort_by_digest = sort_by_digest_4_8;
9090 opti_type = OPTI_TYPE_ZERO_BYTE;
9091 dgst_pos0 = 0;
9092 dgst_pos1 = 1;
9093 dgst_pos2 = 2;
9094 dgst_pos3 = 3;
9095 break;
9096
9097 case 6900: hash_type = HASH_TYPE_GOST;
9098 salt_type = SALT_TYPE_NONE;
9099 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9100 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9101 kern_type = KERN_TYPE_GOST;
9102 dgst_size = DGST_SIZE_4_8;
9103 parse_func = gost_parse_hash;
9104 sort_by_digest = sort_by_digest_4_8;
9105 opti_type = OPTI_TYPE_ZERO_BYTE;
9106 dgst_pos0 = 0;
9107 dgst_pos1 = 1;
9108 dgst_pos2 = 2;
9109 dgst_pos3 = 3;
9110 break;
9111
9112 case 7100: hash_type = HASH_TYPE_SHA512;
9113 salt_type = SALT_TYPE_EMBEDDED;
9114 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9115 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9116 kern_type = KERN_TYPE_PBKDF2_SHA512;
9117 dgst_size = DGST_SIZE_8_16;
9118 parse_func = sha512osx_parse_hash;
9119 sort_by_digest = sort_by_digest_8_16;
9120 opti_type = OPTI_TYPE_ZERO_BYTE
9121 | OPTI_TYPE_USES_BITS_64;
9122 dgst_pos0 = 0;
9123 dgst_pos1 = 1;
9124 dgst_pos2 = 2;
9125 dgst_pos3 = 3;
9126 break;
9127
9128 case 7200: hash_type = HASH_TYPE_SHA512;
9129 salt_type = SALT_TYPE_EMBEDDED;
9130 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9131 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9132 kern_type = KERN_TYPE_PBKDF2_SHA512;
9133 dgst_size = DGST_SIZE_8_16;
9134 parse_func = sha512grub_parse_hash;
9135 sort_by_digest = sort_by_digest_8_16;
9136 opti_type = OPTI_TYPE_ZERO_BYTE
9137 | OPTI_TYPE_USES_BITS_64;
9138 dgst_pos0 = 0;
9139 dgst_pos1 = 1;
9140 dgst_pos2 = 2;
9141 dgst_pos3 = 3;
9142 break;
9143
9144 case 7300: hash_type = HASH_TYPE_SHA1;
9145 salt_type = SALT_TYPE_EMBEDDED;
9146 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9147 opts_type = OPTS_TYPE_PT_GENERATE_BE
9148 | OPTS_TYPE_ST_ADD80
9149 | OPTS_TYPE_ST_ADDBITS15;
9150 kern_type = KERN_TYPE_RAKP;
9151 dgst_size = DGST_SIZE_4_5;
9152 parse_func = rakp_parse_hash;
9153 sort_by_digest = sort_by_digest_4_5;
9154 opti_type = OPTI_TYPE_ZERO_BYTE
9155 | OPTI_TYPE_NOT_ITERATED;
9156 dgst_pos0 = 3;
9157 dgst_pos1 = 4;
9158 dgst_pos2 = 2;
9159 dgst_pos3 = 1;
9160 break;
9161
9162 case 7400: hash_type = HASH_TYPE_SHA256;
9163 salt_type = SALT_TYPE_EMBEDDED;
9164 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9165 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9166 kern_type = KERN_TYPE_SHA256CRYPT;
9167 dgst_size = DGST_SIZE_4_8;
9168 parse_func = sha256crypt_parse_hash;
9169 sort_by_digest = sort_by_digest_4_8;
9170 opti_type = OPTI_TYPE_ZERO_BYTE;
9171 dgst_pos0 = 0;
9172 dgst_pos1 = 1;
9173 dgst_pos2 = 2;
9174 dgst_pos3 = 3;
9175 break;
9176
9177 case 7500: hash_type = HASH_TYPE_KRB5PA;
9178 salt_type = SALT_TYPE_EMBEDDED;
9179 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9180 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9181 kern_type = KERN_TYPE_KRB5PA;
9182 dgst_size = DGST_SIZE_4_4;
9183 parse_func = krb5pa_parse_hash;
9184 sort_by_digest = sort_by_digest_4_4;
9185 opti_type = OPTI_TYPE_ZERO_BYTE
9186 | OPTI_TYPE_NOT_ITERATED;
9187 dgst_pos0 = 0;
9188 dgst_pos1 = 1;
9189 dgst_pos2 = 2;
9190 dgst_pos3 = 3;
9191 break;
9192
9193 case 7600: hash_type = HASH_TYPE_SHA1;
9194 salt_type = SALT_TYPE_INTERN;
9195 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9196 opts_type = OPTS_TYPE_PT_GENERATE_BE
9197 | OPTS_TYPE_PT_ADD80
9198 | OPTS_TYPE_PT_ADDBITS15;
9199 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9200 dgst_size = DGST_SIZE_4_5;
9201 parse_func = redmine_parse_hash;
9202 sort_by_digest = sort_by_digest_4_5;
9203 opti_type = OPTI_TYPE_ZERO_BYTE
9204 | OPTI_TYPE_PRECOMPUTE_INIT
9205 | OPTI_TYPE_EARLY_SKIP
9206 | OPTI_TYPE_NOT_ITERATED
9207 | OPTI_TYPE_PREPENDED_SALT;
9208 dgst_pos0 = 3;
9209 dgst_pos1 = 4;
9210 dgst_pos2 = 2;
9211 dgst_pos3 = 1;
9212 break;
9213
9214 case 7700: hash_type = HASH_TYPE_SAPB;
9215 salt_type = SALT_TYPE_EMBEDDED;
9216 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9217 opts_type = OPTS_TYPE_PT_GENERATE_LE
9218 | OPTS_TYPE_PT_UPPER
9219 | OPTS_TYPE_ST_UPPER;
9220 kern_type = KERN_TYPE_SAPB;
9221 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9222 parse_func = sapb_parse_hash;
9223 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9224 opti_type = OPTI_TYPE_ZERO_BYTE
9225 | OPTI_TYPE_PRECOMPUTE_INIT
9226 | OPTI_TYPE_NOT_ITERATED;
9227 dgst_pos0 = 0;
9228 dgst_pos1 = 1;
9229 dgst_pos2 = 2;
9230 dgst_pos3 = 3;
9231 break;
9232
9233 case 7800: hash_type = HASH_TYPE_SAPG;
9234 salt_type = SALT_TYPE_EMBEDDED;
9235 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9236 opts_type = OPTS_TYPE_PT_GENERATE_BE
9237 | OPTS_TYPE_ST_ADD80
9238 | OPTS_TYPE_ST_UPPER;
9239 kern_type = KERN_TYPE_SAPG;
9240 dgst_size = DGST_SIZE_4_5;
9241 parse_func = sapg_parse_hash;
9242 sort_by_digest = sort_by_digest_4_5;
9243 opti_type = OPTI_TYPE_ZERO_BYTE
9244 | OPTI_TYPE_PRECOMPUTE_INIT
9245 | OPTI_TYPE_NOT_ITERATED;
9246 dgst_pos0 = 3;
9247 dgst_pos1 = 4;
9248 dgst_pos2 = 2;
9249 dgst_pos3 = 1;
9250 break;
9251
9252 case 7900: hash_type = HASH_TYPE_SHA512;
9253 salt_type = SALT_TYPE_EMBEDDED;
9254 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9255 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9256 kern_type = KERN_TYPE_DRUPAL7;
9257 dgst_size = DGST_SIZE_8_8;
9258 parse_func = drupal7_parse_hash;
9259 sort_by_digest = sort_by_digest_8_8;
9260 opti_type = OPTI_TYPE_ZERO_BYTE
9261 | OPTI_TYPE_USES_BITS_64;
9262 dgst_pos0 = 0;
9263 dgst_pos1 = 1;
9264 dgst_pos2 = 2;
9265 dgst_pos3 = 3;
9266 break;
9267
9268 case 8000: hash_type = HASH_TYPE_SHA256;
9269 salt_type = SALT_TYPE_EMBEDDED;
9270 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9271 opts_type = OPTS_TYPE_PT_GENERATE_BE
9272 | OPTS_TYPE_PT_UNICODE
9273 | OPTS_TYPE_ST_ADD80
9274 | OPTS_TYPE_ST_HEX;
9275 kern_type = KERN_TYPE_SYBASEASE;
9276 dgst_size = DGST_SIZE_4_8;
9277 parse_func = sybasease_parse_hash;
9278 sort_by_digest = sort_by_digest_4_8;
9279 opti_type = OPTI_TYPE_ZERO_BYTE
9280 | OPTI_TYPE_PRECOMPUTE_INIT
9281 | OPTI_TYPE_EARLY_SKIP
9282 | OPTI_TYPE_NOT_ITERATED
9283 | OPTI_TYPE_RAW_HASH;
9284 dgst_pos0 = 3;
9285 dgst_pos1 = 7;
9286 dgst_pos2 = 2;
9287 dgst_pos3 = 6;
9288 break;
9289
9290 case 8100: hash_type = HASH_TYPE_SHA1;
9291 salt_type = SALT_TYPE_EMBEDDED;
9292 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9293 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9294 kern_type = KERN_TYPE_NETSCALER;
9295 dgst_size = DGST_SIZE_4_5;
9296 parse_func = netscaler_parse_hash;
9297 sort_by_digest = sort_by_digest_4_5;
9298 opti_type = OPTI_TYPE_ZERO_BYTE
9299 | OPTI_TYPE_PRECOMPUTE_INIT
9300 | OPTI_TYPE_PRECOMPUTE_MERKLE
9301 | OPTI_TYPE_EARLY_SKIP
9302 | OPTI_TYPE_NOT_ITERATED
9303 | OPTI_TYPE_PREPENDED_SALT
9304 | OPTI_TYPE_RAW_HASH;
9305 dgst_pos0 = 3;
9306 dgst_pos1 = 4;
9307 dgst_pos2 = 2;
9308 dgst_pos3 = 1;
9309 break;
9310
9311 case 8200: hash_type = HASH_TYPE_SHA256;
9312 salt_type = SALT_TYPE_EMBEDDED;
9313 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9314 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9315 kern_type = KERN_TYPE_CLOUDKEY;
9316 dgst_size = DGST_SIZE_4_8;
9317 parse_func = cloudkey_parse_hash;
9318 sort_by_digest = sort_by_digest_4_8;
9319 opti_type = OPTI_TYPE_ZERO_BYTE;
9320 dgst_pos0 = 0;
9321 dgst_pos1 = 1;
9322 dgst_pos2 = 2;
9323 dgst_pos3 = 3;
9324 break;
9325
9326 case 8300: hash_type = HASH_TYPE_SHA1;
9327 salt_type = SALT_TYPE_EMBEDDED;
9328 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9329 opts_type = OPTS_TYPE_PT_GENERATE_BE
9330 | OPTS_TYPE_ST_HEX
9331 | OPTS_TYPE_ST_ADD80;
9332 kern_type = KERN_TYPE_NSEC3;
9333 dgst_size = DGST_SIZE_4_5;
9334 parse_func = nsec3_parse_hash;
9335 sort_by_digest = sort_by_digest_4_5;
9336 opti_type = OPTI_TYPE_ZERO_BYTE;
9337 dgst_pos0 = 3;
9338 dgst_pos1 = 4;
9339 dgst_pos2 = 2;
9340 dgst_pos3 = 1;
9341 break;
9342
9343 case 8400: hash_type = HASH_TYPE_SHA1;
9344 salt_type = SALT_TYPE_INTERN;
9345 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9346 opts_type = OPTS_TYPE_PT_GENERATE_BE
9347 | OPTS_TYPE_PT_ADD80
9348 | OPTS_TYPE_PT_ADDBITS15;
9349 kern_type = KERN_TYPE_WBB3;
9350 dgst_size = DGST_SIZE_4_5;
9351 parse_func = wbb3_parse_hash;
9352 sort_by_digest = sort_by_digest_4_5;
9353 opti_type = OPTI_TYPE_ZERO_BYTE
9354 | OPTI_TYPE_PRECOMPUTE_INIT
9355 | OPTI_TYPE_NOT_ITERATED;
9356 dgst_pos0 = 3;
9357 dgst_pos1 = 4;
9358 dgst_pos2 = 2;
9359 dgst_pos3 = 1;
9360 break;
9361
9362 case 8500: hash_type = HASH_TYPE_DESRACF;
9363 salt_type = SALT_TYPE_EMBEDDED;
9364 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9365 opts_type = OPTS_TYPE_PT_GENERATE_LE
9366 | OPTS_TYPE_ST_UPPER;
9367 kern_type = KERN_TYPE_RACF;
9368 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9369 parse_func = racf_parse_hash;
9370 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9371 opti_type = OPTI_TYPE_ZERO_BYTE
9372 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9373 dgst_pos0 = 0;
9374 dgst_pos1 = 1;
9375 dgst_pos2 = 2;
9376 dgst_pos3 = 3;
9377 break;
9378
9379 case 8600: hash_type = HASH_TYPE_LOTUS5;
9380 salt_type = SALT_TYPE_NONE;
9381 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9382 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9383 kern_type = KERN_TYPE_LOTUS5;
9384 dgst_size = DGST_SIZE_4_4;
9385 parse_func = lotus5_parse_hash;
9386 sort_by_digest = sort_by_digest_4_4;
9387 opti_type = OPTI_TYPE_EARLY_SKIP
9388 | OPTI_TYPE_NOT_ITERATED
9389 | OPTI_TYPE_NOT_SALTED
9390 | OPTI_TYPE_RAW_HASH;
9391 dgst_pos0 = 0;
9392 dgst_pos1 = 1;
9393 dgst_pos2 = 2;
9394 dgst_pos3 = 3;
9395 break;
9396
9397 case 8700: hash_type = HASH_TYPE_LOTUS6;
9398 salt_type = SALT_TYPE_EMBEDDED;
9399 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9400 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9401 kern_type = KERN_TYPE_LOTUS6;
9402 dgst_size = DGST_SIZE_4_4;
9403 parse_func = lotus6_parse_hash;
9404 sort_by_digest = sort_by_digest_4_4;
9405 opti_type = OPTI_TYPE_EARLY_SKIP
9406 | OPTI_TYPE_NOT_ITERATED
9407 | OPTI_TYPE_RAW_HASH;
9408 dgst_pos0 = 0;
9409 dgst_pos1 = 1;
9410 dgst_pos2 = 2;
9411 dgst_pos3 = 3;
9412 break;
9413
9414 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9415 salt_type = SALT_TYPE_EMBEDDED;
9416 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9417 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9418 kern_type = KERN_TYPE_ANDROIDFDE;
9419 dgst_size = DGST_SIZE_4_4;
9420 parse_func = androidfde_parse_hash;
9421 sort_by_digest = sort_by_digest_4_4;
9422 opti_type = OPTI_TYPE_ZERO_BYTE;
9423 dgst_pos0 = 0;
9424 dgst_pos1 = 1;
9425 dgst_pos2 = 2;
9426 dgst_pos3 = 3;
9427 break;
9428
9429 case 8900: hash_type = HASH_TYPE_SCRYPT;
9430 salt_type = SALT_TYPE_EMBEDDED;
9431 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9432 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9433 kern_type = KERN_TYPE_SCRYPT;
9434 dgst_size = DGST_SIZE_4_8;
9435 parse_func = scrypt_parse_hash;
9436 sort_by_digest = sort_by_digest_4_8;
9437 opti_type = OPTI_TYPE_ZERO_BYTE;
9438 dgst_pos0 = 0;
9439 dgst_pos1 = 1;
9440 dgst_pos2 = 2;
9441 dgst_pos3 = 3;
9442 break;
9443
9444 case 9000: hash_type = HASH_TYPE_SHA1;
9445 salt_type = SALT_TYPE_EMBEDDED;
9446 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9447 opts_type = OPTS_TYPE_PT_GENERATE_LE
9448 | OPTS_TYPE_ST_GENERATE_LE;
9449 kern_type = KERN_TYPE_PSAFE2;
9450 dgst_size = DGST_SIZE_4_5;
9451 parse_func = psafe2_parse_hash;
9452 sort_by_digest = sort_by_digest_4_5;
9453 opti_type = OPTI_TYPE_ZERO_BYTE;
9454 dgst_pos0 = 0;
9455 dgst_pos1 = 1;
9456 dgst_pos2 = 2;
9457 dgst_pos3 = 3;
9458 break;
9459
9460 case 9100: hash_type = HASH_TYPE_LOTUS8;
9461 salt_type = SALT_TYPE_EMBEDDED;
9462 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9463 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9464 kern_type = KERN_TYPE_LOTUS8;
9465 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9466 parse_func = lotus8_parse_hash;
9467 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9468 opti_type = OPTI_TYPE_ZERO_BYTE;
9469 dgst_pos0 = 0;
9470 dgst_pos1 = 1;
9471 dgst_pos2 = 2;
9472 dgst_pos3 = 3;
9473 break;
9474
9475 case 9200: hash_type = HASH_TYPE_SHA256;
9476 salt_type = SALT_TYPE_EMBEDDED;
9477 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9478 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9479 kern_type = KERN_TYPE_PBKDF2_SHA256;
9480 dgst_size = DGST_SIZE_4_32;
9481 parse_func = cisco8_parse_hash;
9482 sort_by_digest = sort_by_digest_4_32;
9483 opti_type = OPTI_TYPE_ZERO_BYTE;
9484 dgst_pos0 = 0;
9485 dgst_pos1 = 1;
9486 dgst_pos2 = 2;
9487 dgst_pos3 = 3;
9488 break;
9489
9490 case 9300: hash_type = HASH_TYPE_SCRYPT;
9491 salt_type = SALT_TYPE_EMBEDDED;
9492 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9493 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9494 kern_type = KERN_TYPE_SCRYPT;
9495 dgst_size = DGST_SIZE_4_8;
9496 parse_func = cisco9_parse_hash;
9497 sort_by_digest = sort_by_digest_4_8;
9498 opti_type = OPTI_TYPE_ZERO_BYTE;
9499 dgst_pos0 = 0;
9500 dgst_pos1 = 1;
9501 dgst_pos2 = 2;
9502 dgst_pos3 = 3;
9503 break;
9504
9505 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9506 salt_type = SALT_TYPE_EMBEDDED;
9507 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9508 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9509 kern_type = KERN_TYPE_OFFICE2007;
9510 dgst_size = DGST_SIZE_4_4;
9511 parse_func = office2007_parse_hash;
9512 sort_by_digest = sort_by_digest_4_4;
9513 opti_type = OPTI_TYPE_ZERO_BYTE;
9514 dgst_pos0 = 0;
9515 dgst_pos1 = 1;
9516 dgst_pos2 = 2;
9517 dgst_pos3 = 3;
9518 break;
9519
9520 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9521 salt_type = SALT_TYPE_EMBEDDED;
9522 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9523 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9524 kern_type = KERN_TYPE_OFFICE2010;
9525 dgst_size = DGST_SIZE_4_4;
9526 parse_func = office2010_parse_hash;
9527 sort_by_digest = sort_by_digest_4_4;
9528 opti_type = OPTI_TYPE_ZERO_BYTE;
9529 dgst_pos0 = 0;
9530 dgst_pos1 = 1;
9531 dgst_pos2 = 2;
9532 dgst_pos3 = 3;
9533 break;
9534
9535 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9536 salt_type = SALT_TYPE_EMBEDDED;
9537 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9538 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9539 kern_type = KERN_TYPE_OFFICE2013;
9540 dgst_size = DGST_SIZE_4_4;
9541 parse_func = office2013_parse_hash;
9542 sort_by_digest = sort_by_digest_4_4;
9543 opti_type = OPTI_TYPE_ZERO_BYTE;
9544 dgst_pos0 = 0;
9545 dgst_pos1 = 1;
9546 dgst_pos2 = 2;
9547 dgst_pos3 = 3;
9548 break;
9549
9550 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9551 salt_type = SALT_TYPE_EMBEDDED;
9552 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9553 opts_type = OPTS_TYPE_PT_GENERATE_LE
9554 | OPTS_TYPE_PT_ADD80
9555 | OPTS_TYPE_PT_UNICODE;
9556 kern_type = KERN_TYPE_OLDOFFICE01;
9557 dgst_size = DGST_SIZE_4_4;
9558 parse_func = oldoffice01_parse_hash;
9559 sort_by_digest = sort_by_digest_4_4;
9560 opti_type = OPTI_TYPE_ZERO_BYTE
9561 | OPTI_TYPE_PRECOMPUTE_INIT
9562 | OPTI_TYPE_NOT_ITERATED;
9563 dgst_pos0 = 0;
9564 dgst_pos1 = 1;
9565 dgst_pos2 = 2;
9566 dgst_pos3 = 3;
9567 break;
9568
9569 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9570 salt_type = SALT_TYPE_EMBEDDED;
9571 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9572 opts_type = OPTS_TYPE_PT_GENERATE_LE
9573 | OPTS_TYPE_PT_ADD80;
9574 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9575 dgst_size = DGST_SIZE_4_4;
9576 parse_func = oldoffice01cm1_parse_hash;
9577 sort_by_digest = sort_by_digest_4_4;
9578 opti_type = OPTI_TYPE_ZERO_BYTE
9579 | OPTI_TYPE_PRECOMPUTE_INIT
9580 | OPTI_TYPE_NOT_ITERATED;
9581 dgst_pos0 = 0;
9582 dgst_pos1 = 1;
9583 dgst_pos2 = 2;
9584 dgst_pos3 = 3;
9585 break;
9586
9587 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9588 salt_type = SALT_TYPE_EMBEDDED;
9589 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9590 opts_type = OPTS_TYPE_PT_GENERATE_LE
9591 | OPTS_TYPE_PT_ADD80
9592 | OPTS_TYPE_PT_UNICODE
9593 | OPTS_TYPE_PT_NEVERCRACK;
9594 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9595 dgst_size = DGST_SIZE_4_4;
9596 parse_func = oldoffice01cm2_parse_hash;
9597 sort_by_digest = sort_by_digest_4_4;
9598 opti_type = OPTI_TYPE_ZERO_BYTE
9599 | OPTI_TYPE_PRECOMPUTE_INIT
9600 | OPTI_TYPE_NOT_ITERATED;
9601 dgst_pos0 = 0;
9602 dgst_pos1 = 1;
9603 dgst_pos2 = 2;
9604 dgst_pos3 = 3;
9605 break;
9606
9607 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9608 salt_type = SALT_TYPE_EMBEDDED;
9609 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9610 opts_type = OPTS_TYPE_PT_GENERATE_BE
9611 | OPTS_TYPE_PT_ADD80
9612 | OPTS_TYPE_PT_UNICODE;
9613 kern_type = KERN_TYPE_OLDOFFICE34;
9614 dgst_size = DGST_SIZE_4_4;
9615 parse_func = oldoffice34_parse_hash;
9616 sort_by_digest = sort_by_digest_4_4;
9617 opti_type = OPTI_TYPE_ZERO_BYTE
9618 | OPTI_TYPE_PRECOMPUTE_INIT
9619 | OPTI_TYPE_NOT_ITERATED;
9620 dgst_pos0 = 0;
9621 dgst_pos1 = 1;
9622 dgst_pos2 = 2;
9623 dgst_pos3 = 3;
9624 break;
9625
9626 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9627 salt_type = SALT_TYPE_EMBEDDED;
9628 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9629 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9630 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9631 dgst_size = DGST_SIZE_4_4;
9632 parse_func = oldoffice34cm1_parse_hash;
9633 sort_by_digest = sort_by_digest_4_4;
9634 opti_type = OPTI_TYPE_ZERO_BYTE
9635 | OPTI_TYPE_PRECOMPUTE_INIT
9636 | OPTI_TYPE_NOT_ITERATED;
9637 dgst_pos0 = 0;
9638 dgst_pos1 = 1;
9639 dgst_pos2 = 2;
9640 dgst_pos3 = 3;
9641 break;
9642
9643 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9644 salt_type = SALT_TYPE_EMBEDDED;
9645 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9646 opts_type = OPTS_TYPE_PT_GENERATE_BE
9647 | OPTS_TYPE_PT_ADD80
9648 | OPTS_TYPE_PT_UNICODE
9649 | OPTS_TYPE_PT_NEVERCRACK;
9650 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9651 dgst_size = DGST_SIZE_4_4;
9652 parse_func = oldoffice34cm2_parse_hash;
9653 sort_by_digest = sort_by_digest_4_4;
9654 opti_type = OPTI_TYPE_ZERO_BYTE
9655 | OPTI_TYPE_PRECOMPUTE_INIT
9656 | OPTI_TYPE_NOT_ITERATED;
9657 dgst_pos0 = 0;
9658 dgst_pos1 = 1;
9659 dgst_pos2 = 2;
9660 dgst_pos3 = 3;
9661 break;
9662
9663 case 9900: hash_type = HASH_TYPE_MD5;
9664 salt_type = SALT_TYPE_NONE;
9665 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9666 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9667 kern_type = KERN_TYPE_RADMIN2;
9668 dgst_size = DGST_SIZE_4_4;
9669 parse_func = radmin2_parse_hash;
9670 sort_by_digest = sort_by_digest_4_4;
9671 opti_type = OPTI_TYPE_ZERO_BYTE
9672 | OPTI_TYPE_PRECOMPUTE_INIT
9673 | OPTI_TYPE_EARLY_SKIP
9674 | OPTI_TYPE_NOT_ITERATED
9675 | OPTI_TYPE_NOT_SALTED;
9676 dgst_pos0 = 0;
9677 dgst_pos1 = 3;
9678 dgst_pos2 = 2;
9679 dgst_pos3 = 1;
9680 break;
9681
9682 case 10000: hash_type = HASH_TYPE_SHA256;
9683 salt_type = SALT_TYPE_EMBEDDED;
9684 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9685 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9686 kern_type = KERN_TYPE_PBKDF2_SHA256;
9687 dgst_size = DGST_SIZE_4_32;
9688 parse_func = djangopbkdf2_parse_hash;
9689 sort_by_digest = sort_by_digest_4_32;
9690 opti_type = OPTI_TYPE_ZERO_BYTE;
9691 dgst_pos0 = 0;
9692 dgst_pos1 = 1;
9693 dgst_pos2 = 2;
9694 dgst_pos3 = 3;
9695 break;
9696
9697 case 10100: hash_type = HASH_TYPE_SIPHASH;
9698 salt_type = SALT_TYPE_EMBEDDED;
9699 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9700 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9701 kern_type = KERN_TYPE_SIPHASH;
9702 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9703 parse_func = siphash_parse_hash;
9704 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9705 opti_type = OPTI_TYPE_ZERO_BYTE
9706 | OPTI_TYPE_NOT_ITERATED
9707 | OPTI_TYPE_RAW_HASH;
9708 dgst_pos0 = 0;
9709 dgst_pos1 = 1;
9710 dgst_pos2 = 2;
9711 dgst_pos3 = 3;
9712 break;
9713
9714 case 10200: hash_type = HASH_TYPE_MD5;
9715 salt_type = SALT_TYPE_EMBEDDED;
9716 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9717 opts_type = OPTS_TYPE_PT_GENERATE_LE
9718 | OPTS_TYPE_ST_ADD80
9719 | OPTS_TYPE_ST_ADDBITS14;
9720 kern_type = KERN_TYPE_HMACMD5_PW;
9721 dgst_size = DGST_SIZE_4_4;
9722 parse_func = crammd5_parse_hash;
9723 sort_by_digest = sort_by_digest_4_4;
9724 opti_type = OPTI_TYPE_ZERO_BYTE
9725 | OPTI_TYPE_NOT_ITERATED;
9726 dgst_pos0 = 0;
9727 dgst_pos1 = 3;
9728 dgst_pos2 = 2;
9729 dgst_pos3 = 1;
9730 break;
9731
9732 case 10300: hash_type = HASH_TYPE_SHA1;
9733 salt_type = SALT_TYPE_EMBEDDED;
9734 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9735 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9736 kern_type = KERN_TYPE_SAPH_SHA1;
9737 dgst_size = DGST_SIZE_4_5;
9738 parse_func = saph_sha1_parse_hash;
9739 sort_by_digest = sort_by_digest_4_5;
9740 opti_type = OPTI_TYPE_ZERO_BYTE;
9741 dgst_pos0 = 0;
9742 dgst_pos1 = 1;
9743 dgst_pos2 = 2;
9744 dgst_pos3 = 3;
9745 break;
9746
9747 case 10400: hash_type = HASH_TYPE_PDFU16;
9748 salt_type = SALT_TYPE_EMBEDDED;
9749 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9750 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9751 kern_type = KERN_TYPE_PDF11;
9752 dgst_size = DGST_SIZE_4_4;
9753 parse_func = pdf11_parse_hash;
9754 sort_by_digest = sort_by_digest_4_4;
9755 opti_type = OPTI_TYPE_ZERO_BYTE
9756 | OPTI_TYPE_NOT_ITERATED;
9757 dgst_pos0 = 0;
9758 dgst_pos1 = 1;
9759 dgst_pos2 = 2;
9760 dgst_pos3 = 3;
9761 break;
9762
9763 case 10410: hash_type = HASH_TYPE_PDFU16;
9764 salt_type = SALT_TYPE_EMBEDDED;
9765 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9766 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9767 kern_type = KERN_TYPE_PDF11CM1;
9768 dgst_size = DGST_SIZE_4_4;
9769 parse_func = pdf11cm1_parse_hash;
9770 sort_by_digest = sort_by_digest_4_4;
9771 opti_type = OPTI_TYPE_ZERO_BYTE
9772 | OPTI_TYPE_NOT_ITERATED;
9773 dgst_pos0 = 0;
9774 dgst_pos1 = 1;
9775 dgst_pos2 = 2;
9776 dgst_pos3 = 3;
9777 break;
9778
9779 case 10420: hash_type = HASH_TYPE_PDFU16;
9780 salt_type = SALT_TYPE_EMBEDDED;
9781 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9782 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9783 kern_type = KERN_TYPE_PDF11CM2;
9784 dgst_size = DGST_SIZE_4_4;
9785 parse_func = pdf11cm2_parse_hash;
9786 sort_by_digest = sort_by_digest_4_4;
9787 opti_type = OPTI_TYPE_ZERO_BYTE
9788 | OPTI_TYPE_NOT_ITERATED;
9789 dgst_pos0 = 0;
9790 dgst_pos1 = 1;
9791 dgst_pos2 = 2;
9792 dgst_pos3 = 3;
9793 break;
9794
9795 case 10500: hash_type = HASH_TYPE_PDFU16;
9796 salt_type = SALT_TYPE_EMBEDDED;
9797 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9798 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9799 kern_type = KERN_TYPE_PDF14;
9800 dgst_size = DGST_SIZE_4_4;
9801 parse_func = pdf14_parse_hash;
9802 sort_by_digest = sort_by_digest_4_4;
9803 opti_type = OPTI_TYPE_ZERO_BYTE
9804 | OPTI_TYPE_NOT_ITERATED;
9805 dgst_pos0 = 0;
9806 dgst_pos1 = 1;
9807 dgst_pos2 = 2;
9808 dgst_pos3 = 3;
9809 break;
9810
9811 case 10600: hash_type = HASH_TYPE_SHA256;
9812 salt_type = SALT_TYPE_EMBEDDED;
9813 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9814 opts_type = OPTS_TYPE_PT_GENERATE_BE
9815 | OPTS_TYPE_ST_ADD80
9816 | OPTS_TYPE_ST_ADDBITS15
9817 | OPTS_TYPE_HASH_COPY;
9818 kern_type = KERN_TYPE_SHA256_PWSLT;
9819 dgst_size = DGST_SIZE_4_8;
9820 parse_func = pdf17l3_parse_hash;
9821 sort_by_digest = sort_by_digest_4_8;
9822 opti_type = OPTI_TYPE_ZERO_BYTE
9823 | OPTI_TYPE_PRECOMPUTE_INIT
9824 | OPTI_TYPE_PRECOMPUTE_MERKLE
9825 | OPTI_TYPE_EARLY_SKIP
9826 | OPTI_TYPE_NOT_ITERATED
9827 | OPTI_TYPE_APPENDED_SALT
9828 | OPTI_TYPE_RAW_HASH;
9829 dgst_pos0 = 3;
9830 dgst_pos1 = 7;
9831 dgst_pos2 = 2;
9832 dgst_pos3 = 6;
9833 break;
9834
9835 case 10700: hash_type = HASH_TYPE_PDFU32;
9836 salt_type = SALT_TYPE_EMBEDDED;
9837 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9838 opts_type = OPTS_TYPE_PT_GENERATE_LE
9839 | OPTS_TYPE_HASH_COPY;
9840 kern_type = KERN_TYPE_PDF17L8;
9841 dgst_size = DGST_SIZE_4_8;
9842 parse_func = pdf17l8_parse_hash;
9843 sort_by_digest = sort_by_digest_4_8;
9844 opti_type = OPTI_TYPE_ZERO_BYTE
9845 | OPTI_TYPE_NOT_ITERATED;
9846 dgst_pos0 = 0;
9847 dgst_pos1 = 1;
9848 dgst_pos2 = 2;
9849 dgst_pos3 = 3;
9850 break;
9851
9852 case 10800: hash_type = HASH_TYPE_SHA384;
9853 salt_type = SALT_TYPE_NONE;
9854 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9855 opts_type = OPTS_TYPE_PT_GENERATE_BE
9856 | OPTS_TYPE_PT_ADD80
9857 | OPTS_TYPE_PT_ADDBITS15;
9858 kern_type = KERN_TYPE_SHA384;
9859 dgst_size = DGST_SIZE_8_8;
9860 parse_func = sha384_parse_hash;
9861 sort_by_digest = sort_by_digest_8_8;
9862 opti_type = OPTI_TYPE_ZERO_BYTE
9863 | OPTI_TYPE_PRECOMPUTE_INIT
9864 | OPTI_TYPE_PRECOMPUTE_MERKLE
9865 | OPTI_TYPE_EARLY_SKIP
9866 | OPTI_TYPE_NOT_ITERATED
9867 | OPTI_TYPE_NOT_SALTED
9868 | OPTI_TYPE_USES_BITS_64
9869 | OPTI_TYPE_RAW_HASH;
9870 dgst_pos0 = 6;
9871 dgst_pos1 = 7;
9872 dgst_pos2 = 4;
9873 dgst_pos3 = 5;
9874 break;
9875
9876 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9877 salt_type = SALT_TYPE_EMBEDDED;
9878 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9879 opts_type = OPTS_TYPE_PT_GENERATE_LE
9880 | OPTS_TYPE_ST_BASE64
9881 | OPTS_TYPE_HASH_COPY;
9882 kern_type = KERN_TYPE_PBKDF2_SHA256;
9883 dgst_size = DGST_SIZE_4_32;
9884 parse_func = pbkdf2_sha256_parse_hash;
9885 sort_by_digest = sort_by_digest_4_32;
9886 opti_type = OPTI_TYPE_ZERO_BYTE;
9887 dgst_pos0 = 0;
9888 dgst_pos1 = 1;
9889 dgst_pos2 = 2;
9890 dgst_pos3 = 3;
9891 break;
9892
9893 case 11000: hash_type = HASH_TYPE_MD5;
9894 salt_type = SALT_TYPE_INTERN;
9895 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9896 opts_type = OPTS_TYPE_PT_GENERATE_LE
9897 | OPTS_TYPE_PT_ADD80;
9898 kern_type = KERN_TYPE_PRESTASHOP;
9899 dgst_size = DGST_SIZE_4_4;
9900 parse_func = prestashop_parse_hash;
9901 sort_by_digest = sort_by_digest_4_4;
9902 opti_type = OPTI_TYPE_ZERO_BYTE
9903 | OPTI_TYPE_PRECOMPUTE_INIT
9904 | OPTI_TYPE_NOT_ITERATED
9905 | OPTI_TYPE_PREPENDED_SALT;
9906 dgst_pos0 = 0;
9907 dgst_pos1 = 3;
9908 dgst_pos2 = 2;
9909 dgst_pos3 = 1;
9910 break;
9911
9912 case 11100: hash_type = HASH_TYPE_MD5;
9913 salt_type = SALT_TYPE_EMBEDDED;
9914 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9915 opts_type = OPTS_TYPE_PT_GENERATE_LE
9916 | OPTS_TYPE_ST_ADD80;
9917 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9918 dgst_size = DGST_SIZE_4_4;
9919 parse_func = postgresql_auth_parse_hash;
9920 sort_by_digest = sort_by_digest_4_4;
9921 opti_type = OPTI_TYPE_ZERO_BYTE
9922 | OPTI_TYPE_PRECOMPUTE_INIT
9923 | OPTI_TYPE_PRECOMPUTE_MERKLE
9924 | OPTI_TYPE_EARLY_SKIP;
9925 dgst_pos0 = 0;
9926 dgst_pos1 = 3;
9927 dgst_pos2 = 2;
9928 dgst_pos3 = 1;
9929 break;
9930
9931 case 11200: hash_type = HASH_TYPE_SHA1;
9932 salt_type = SALT_TYPE_EMBEDDED;
9933 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9934 opts_type = OPTS_TYPE_PT_GENERATE_BE
9935 | OPTS_TYPE_PT_ADD80
9936 | OPTS_TYPE_ST_HEX;
9937 kern_type = KERN_TYPE_MYSQL_AUTH;
9938 dgst_size = DGST_SIZE_4_5;
9939 parse_func = mysql_auth_parse_hash;
9940 sort_by_digest = sort_by_digest_4_5;
9941 opti_type = OPTI_TYPE_ZERO_BYTE
9942 | OPTI_TYPE_EARLY_SKIP;
9943 dgst_pos0 = 3;
9944 dgst_pos1 = 4;
9945 dgst_pos2 = 2;
9946 dgst_pos3 = 1;
9947 break;
9948
9949 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9950 salt_type = SALT_TYPE_EMBEDDED;
9951 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9952 opts_type = OPTS_TYPE_PT_GENERATE_LE
9953 | OPTS_TYPE_ST_HEX
9954 | OPTS_TYPE_ST_ADD80;
9955 kern_type = KERN_TYPE_BITCOIN_WALLET;
9956 dgst_size = DGST_SIZE_4_4;
9957 parse_func = bitcoin_wallet_parse_hash;
9958 sort_by_digest = sort_by_digest_4_4;
9959 opti_type = OPTI_TYPE_ZERO_BYTE;
9960 dgst_pos0 = 0;
9961 dgst_pos1 = 1;
9962 dgst_pos2 = 2;
9963 dgst_pos3 = 3;
9964 break;
9965
9966 case 11400: hash_type = HASH_TYPE_MD5;
9967 salt_type = SALT_TYPE_EMBEDDED;
9968 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9969 opts_type = OPTS_TYPE_PT_GENERATE_LE
9970 | OPTS_TYPE_PT_ADD80
9971 | OPTS_TYPE_HASH_COPY;
9972 kern_type = KERN_TYPE_SIP_AUTH;
9973 dgst_size = DGST_SIZE_4_4;
9974 parse_func = sip_auth_parse_hash;
9975 sort_by_digest = sort_by_digest_4_4;
9976 opti_type = OPTI_TYPE_ZERO_BYTE;
9977 dgst_pos0 = 0;
9978 dgst_pos1 = 3;
9979 dgst_pos2 = 2;
9980 dgst_pos3 = 1;
9981 break;
9982
9983 case 11500: hash_type = HASH_TYPE_CRC32;
9984 salt_type = SALT_TYPE_INTERN;
9985 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9986 opts_type = OPTS_TYPE_PT_GENERATE_LE
9987 | OPTS_TYPE_ST_GENERATE_LE
9988 | OPTS_TYPE_ST_HEX;
9989 kern_type = KERN_TYPE_CRC32;
9990 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9991 parse_func = crc32_parse_hash;
9992 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9993 opti_type = OPTI_TYPE_ZERO_BYTE;
9994 dgst_pos0 = 0;
9995 dgst_pos1 = 1;
9996 dgst_pos2 = 2;
9997 dgst_pos3 = 3;
9998 break;
9999
10000 case 11600: hash_type = HASH_TYPE_AES;
10001 salt_type = SALT_TYPE_EMBEDDED;
10002 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10003 opts_type = OPTS_TYPE_PT_GENERATE_LE
10004 | OPTS_TYPE_PT_NEVERCRACK;
10005 kern_type = KERN_TYPE_SEVEN_ZIP;
10006 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10007 parse_func = seven_zip_parse_hash;
10008 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10009 opti_type = OPTI_TYPE_ZERO_BYTE;
10010 dgst_pos0 = 0;
10011 dgst_pos1 = 1;
10012 dgst_pos2 = 2;
10013 dgst_pos3 = 3;
10014 break;
10015
10016 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10017 salt_type = SALT_TYPE_NONE;
10018 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10019 opts_type = OPTS_TYPE_PT_GENERATE_LE
10020 | OPTS_TYPE_PT_ADD01;
10021 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10022 dgst_size = DGST_SIZE_4_8;
10023 parse_func = gost2012sbog_256_parse_hash;
10024 sort_by_digest = sort_by_digest_4_8;
10025 opti_type = OPTI_TYPE_ZERO_BYTE;
10026 dgst_pos0 = 0;
10027 dgst_pos1 = 1;
10028 dgst_pos2 = 2;
10029 dgst_pos3 = 3;
10030 break;
10031
10032 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10033 salt_type = SALT_TYPE_NONE;
10034 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10035 opts_type = OPTS_TYPE_PT_GENERATE_LE
10036 | OPTS_TYPE_PT_ADD01;
10037 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10038 dgst_size = DGST_SIZE_4_16;
10039 parse_func = gost2012sbog_512_parse_hash;
10040 sort_by_digest = sort_by_digest_4_16;
10041 opti_type = OPTI_TYPE_ZERO_BYTE;
10042 dgst_pos0 = 0;
10043 dgst_pos1 = 1;
10044 dgst_pos2 = 2;
10045 dgst_pos3 = 3;
10046 break;
10047
10048 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10049 salt_type = SALT_TYPE_EMBEDDED;
10050 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10051 opts_type = OPTS_TYPE_PT_GENERATE_LE
10052 | OPTS_TYPE_ST_BASE64
10053 | OPTS_TYPE_HASH_COPY;
10054 kern_type = KERN_TYPE_PBKDF2_MD5;
10055 dgst_size = DGST_SIZE_4_32;
10056 parse_func = pbkdf2_md5_parse_hash;
10057 sort_by_digest = sort_by_digest_4_32;
10058 opti_type = OPTI_TYPE_ZERO_BYTE;
10059 dgst_pos0 = 0;
10060 dgst_pos1 = 1;
10061 dgst_pos2 = 2;
10062 dgst_pos3 = 3;
10063 break;
10064
10065 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10066 salt_type = SALT_TYPE_EMBEDDED;
10067 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10068 opts_type = OPTS_TYPE_PT_GENERATE_LE
10069 | OPTS_TYPE_ST_BASE64
10070 | OPTS_TYPE_HASH_COPY;
10071 kern_type = KERN_TYPE_PBKDF2_SHA1;
10072 dgst_size = DGST_SIZE_4_32;
10073 parse_func = pbkdf2_sha1_parse_hash;
10074 sort_by_digest = sort_by_digest_4_32;
10075 opti_type = OPTI_TYPE_ZERO_BYTE;
10076 dgst_pos0 = 0;
10077 dgst_pos1 = 1;
10078 dgst_pos2 = 2;
10079 dgst_pos3 = 3;
10080 break;
10081
10082 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10083 salt_type = SALT_TYPE_EMBEDDED;
10084 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10085 opts_type = OPTS_TYPE_PT_GENERATE_LE
10086 | OPTS_TYPE_ST_BASE64
10087 | OPTS_TYPE_HASH_COPY;
10088 kern_type = KERN_TYPE_PBKDF2_SHA512;
10089 dgst_size = DGST_SIZE_8_16;
10090 parse_func = pbkdf2_sha512_parse_hash;
10091 sort_by_digest = sort_by_digest_8_16;
10092 opti_type = OPTI_TYPE_ZERO_BYTE
10093 | OPTI_TYPE_USES_BITS_64;
10094 dgst_pos0 = 0;
10095 dgst_pos1 = 1;
10096 dgst_pos2 = 2;
10097 dgst_pos3 = 3;
10098 break;
10099
10100 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10101 salt_type = SALT_TYPE_EMBEDDED;
10102 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10103 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10104 kern_type = KERN_TYPE_ECRYPTFS;
10105 dgst_size = DGST_SIZE_8_8;
10106 parse_func = ecryptfs_parse_hash;
10107 sort_by_digest = sort_by_digest_8_8;
10108 opti_type = OPTI_TYPE_ZERO_BYTE
10109 | OPTI_TYPE_USES_BITS_64;
10110 dgst_pos0 = 0;
10111 dgst_pos1 = 1;
10112 dgst_pos2 = 2;
10113 dgst_pos3 = 3;
10114 break;
10115
10116 case 12300: hash_type = HASH_TYPE_ORACLET;
10117 salt_type = SALT_TYPE_EMBEDDED;
10118 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10119 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10120 kern_type = KERN_TYPE_ORACLET;
10121 dgst_size = DGST_SIZE_8_16;
10122 parse_func = oraclet_parse_hash;
10123 sort_by_digest = sort_by_digest_8_16;
10124 opti_type = OPTI_TYPE_ZERO_BYTE
10125 | OPTI_TYPE_USES_BITS_64;
10126 dgst_pos0 = 0;
10127 dgst_pos1 = 1;
10128 dgst_pos2 = 2;
10129 dgst_pos3 = 3;
10130 break;
10131
10132 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10133 salt_type = SALT_TYPE_EMBEDDED;
10134 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10135 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10136 kern_type = KERN_TYPE_BSDICRYPT;
10137 dgst_size = DGST_SIZE_4_4;
10138 parse_func = bsdicrypt_parse_hash;
10139 sort_by_digest = sort_by_digest_4_4;
10140 opti_type = OPTI_TYPE_ZERO_BYTE
10141 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10142 dgst_pos0 = 0;
10143 dgst_pos1 = 1;
10144 dgst_pos2 = 2;
10145 dgst_pos3 = 3;
10146 break;
10147
10148 case 12500: hash_type = HASH_TYPE_RAR3HP;
10149 salt_type = SALT_TYPE_EMBEDDED;
10150 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10151 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10152 kern_type = KERN_TYPE_RAR3;
10153 dgst_size = DGST_SIZE_4_4;
10154 parse_func = rar3hp_parse_hash;
10155 sort_by_digest = sort_by_digest_4_4;
10156 opti_type = OPTI_TYPE_ZERO_BYTE;
10157 dgst_pos0 = 0;
10158 dgst_pos1 = 1;
10159 dgst_pos2 = 2;
10160 dgst_pos3 = 3;
10161 break;
10162
10163 case 12600: hash_type = HASH_TYPE_SHA256;
10164 salt_type = SALT_TYPE_INTERN;
10165 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10166 opts_type = OPTS_TYPE_PT_GENERATE_BE
10167 | OPTS_TYPE_PT_ADD80;
10168 kern_type = KERN_TYPE_CF10;
10169 dgst_size = DGST_SIZE_4_8;
10170 parse_func = cf10_parse_hash;
10171 sort_by_digest = sort_by_digest_4_8;
10172 opti_type = OPTI_TYPE_ZERO_BYTE
10173 | OPTI_TYPE_PRECOMPUTE_INIT
10174 | OPTI_TYPE_EARLY_SKIP
10175 | OPTI_TYPE_NOT_ITERATED;
10176 dgst_pos0 = 3;
10177 dgst_pos1 = 7;
10178 dgst_pos2 = 2;
10179 dgst_pos3 = 6;
10180 break;
10181
10182 case 12700: hash_type = HASH_TYPE_AES;
10183 salt_type = SALT_TYPE_EMBEDDED;
10184 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10185 opts_type = OPTS_TYPE_PT_GENERATE_LE
10186 | OPTS_TYPE_HASH_COPY;
10187 kern_type = KERN_TYPE_MYWALLET;
10188 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10189 parse_func = mywallet_parse_hash;
10190 sort_by_digest = sort_by_digest_4_5;
10191 opti_type = OPTI_TYPE_ZERO_BYTE;
10192 dgst_pos0 = 0;
10193 dgst_pos1 = 1;
10194 dgst_pos2 = 2;
10195 dgst_pos3 = 3;
10196 break;
10197
10198 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10199 salt_type = SALT_TYPE_EMBEDDED;
10200 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10201 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10202 kern_type = KERN_TYPE_MS_DRSR;
10203 dgst_size = DGST_SIZE_4_8;
10204 parse_func = ms_drsr_parse_hash;
10205 sort_by_digest = sort_by_digest_4_8;
10206 opti_type = OPTI_TYPE_ZERO_BYTE;
10207 dgst_pos0 = 0;
10208 dgst_pos1 = 1;
10209 dgst_pos2 = 2;
10210 dgst_pos3 = 3;
10211 break;
10212
10213 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10214 salt_type = SALT_TYPE_EMBEDDED;
10215 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10216 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10217 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10218 dgst_size = DGST_SIZE_4_8;
10219 parse_func = androidfde_samsung_parse_hash;
10220 sort_by_digest = sort_by_digest_4_8;
10221 opti_type = OPTI_TYPE_ZERO_BYTE;
10222 dgst_pos0 = 0;
10223 dgst_pos1 = 1;
10224 dgst_pos2 = 2;
10225 dgst_pos3 = 3;
10226 break;
10227
10228 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10229 salt_type = SALT_TYPE_EMBEDDED;
10230 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10231 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10232 kern_type = KERN_TYPE_RAR5;
10233 dgst_size = DGST_SIZE_4_4;
10234 parse_func = rar5_parse_hash;
10235 sort_by_digest = sort_by_digest_4_4;
10236 opti_type = OPTI_TYPE_ZERO_BYTE;
10237 dgst_pos0 = 0;
10238 dgst_pos1 = 1;
10239 dgst_pos2 = 2;
10240 dgst_pos3 = 3;
10241 break;
10242
10243 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10244 salt_type = SALT_TYPE_EMBEDDED;
10245 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10246 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10247 kern_type = KERN_TYPE_KRB5TGS;
10248 dgst_size = DGST_SIZE_4_4;
10249 parse_func = krb5tgs_parse_hash;
10250 sort_by_digest = sort_by_digest_4_4;
10251 opti_type = OPTI_TYPE_ZERO_BYTE
10252 | OPTI_TYPE_NOT_ITERATED;
10253 dgst_pos0 = 0;
10254 dgst_pos1 = 1;
10255 dgst_pos2 = 2;
10256 dgst_pos3 = 3;
10257 break;
10258
10259 case 13200: hash_type = HASH_TYPE_AES;
10260 salt_type = SALT_TYPE_EMBEDDED;
10261 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10262 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10263 kern_type = KERN_TYPE_AXCRYPT;
10264 dgst_size = DGST_SIZE_4_4;
10265 parse_func = axcrypt_parse_hash;
10266 sort_by_digest = sort_by_digest_4_4;
10267 opti_type = OPTI_TYPE_ZERO_BYTE;
10268 dgst_pos0 = 0;
10269 dgst_pos1 = 1;
10270 dgst_pos2 = 2;
10271 dgst_pos3 = 3;
10272 break;
10273
10274 case 13300: hash_type = HASH_TYPE_SHA1;
10275 salt_type = SALT_TYPE_NONE;
10276 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10277 opts_type = OPTS_TYPE_PT_GENERATE_BE
10278 | OPTS_TYPE_PT_ADD80
10279 | OPTS_TYPE_PT_ADDBITS15;
10280 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10281 dgst_size = DGST_SIZE_4_5;
10282 parse_func = sha1axcrypt_parse_hash;
10283 sort_by_digest = sort_by_digest_4_5;
10284 opti_type = OPTI_TYPE_ZERO_BYTE
10285 | OPTI_TYPE_PRECOMPUTE_INIT
10286 | OPTI_TYPE_EARLY_SKIP
10287 | OPTI_TYPE_NOT_ITERATED
10288 | OPTI_TYPE_NOT_SALTED;
10289 dgst_pos0 = 0;
10290 dgst_pos1 = 4;
10291 dgst_pos2 = 3;
10292 dgst_pos3 = 2;
10293 break;
10294
10295 case 13400: hash_type = HASH_TYPE_AES;
10296 salt_type = SALT_TYPE_EMBEDDED;
10297 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10298 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10299 kern_type = KERN_TYPE_KEEPASS;
10300 dgst_size = DGST_SIZE_4_4;
10301 parse_func = keepass_parse_hash;
10302 sort_by_digest = sort_by_digest_4_4;
10303 opti_type = OPTI_TYPE_ZERO_BYTE;
10304 dgst_pos0 = 0;
10305 dgst_pos1 = 1;
10306 dgst_pos2 = 2;
10307 dgst_pos3 = 3;
10308 break;
10309
10310 default: usage_mini_print (PROGNAME); return (-1);
10311 }
10312
10313 /**
10314 * parser
10315 */
10316
10317 data.parse_func = parse_func;
10318
10319 /**
10320 * misc stuff
10321 */
10322
10323 if (hex_salt)
10324 {
10325 if (salt_type == SALT_TYPE_INTERN)
10326 {
10327 opts_type |= OPTS_TYPE_ST_HEX;
10328 }
10329 else
10330 {
10331 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10332
10333 return (-1);
10334 }
10335 }
10336
10337 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10338 | (salt_type == SALT_TYPE_EXTERN)
10339 | (salt_type == SALT_TYPE_EMBEDDED)
10340 | (salt_type == SALT_TYPE_VIRTUAL));
10341
10342 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10343
10344 data.hash_type = hash_type;
10345 data.attack_mode = attack_mode;
10346 data.attack_kern = attack_kern;
10347 data.attack_exec = attack_exec;
10348 data.kern_type = kern_type;
10349 data.opts_type = opts_type;
10350 data.dgst_size = dgst_size;
10351 data.salt_type = salt_type;
10352 data.isSalted = isSalted;
10353 data.sort_by_digest = sort_by_digest;
10354 data.dgst_pos0 = dgst_pos0;
10355 data.dgst_pos1 = dgst_pos1;
10356 data.dgst_pos2 = dgst_pos2;
10357 data.dgst_pos3 = dgst_pos3;
10358
10359 esalt_size = 0;
10360
10361 switch (hash_mode)
10362 {
10363 case 2500: esalt_size = sizeof (wpa_t); break;
10364 case 5300: esalt_size = sizeof (ikepsk_t); break;
10365 case 5400: esalt_size = sizeof (ikepsk_t); break;
10366 case 5500: esalt_size = sizeof (netntlm_t); break;
10367 case 5600: esalt_size = sizeof (netntlm_t); break;
10368 case 6211: esalt_size = sizeof (tc_t); break;
10369 case 6212: esalt_size = sizeof (tc_t); break;
10370 case 6213: esalt_size = sizeof (tc_t); break;
10371 case 6221: esalt_size = sizeof (tc_t); break;
10372 case 6222: esalt_size = sizeof (tc_t); break;
10373 case 6223: esalt_size = sizeof (tc_t); break;
10374 case 6231: esalt_size = sizeof (tc_t); break;
10375 case 6232: esalt_size = sizeof (tc_t); break;
10376 case 6233: esalt_size = sizeof (tc_t); break;
10377 case 6241: esalt_size = sizeof (tc_t); break;
10378 case 6242: esalt_size = sizeof (tc_t); break;
10379 case 6243: esalt_size = sizeof (tc_t); break;
10380 case 6600: esalt_size = sizeof (agilekey_t); break;
10381 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10382 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10383 case 7300: esalt_size = sizeof (rakp_t); break;
10384 case 7500: esalt_size = sizeof (krb5pa_t); break;
10385 case 8200: esalt_size = sizeof (cloudkey_t); break;
10386 case 8800: esalt_size = sizeof (androidfde_t); break;
10387 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10388 case 9400: esalt_size = sizeof (office2007_t); break;
10389 case 9500: esalt_size = sizeof (office2010_t); break;
10390 case 9600: esalt_size = sizeof (office2013_t); break;
10391 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10392 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10393 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10394 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10395 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10396 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10397 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10398 case 10200: esalt_size = sizeof (cram_md5_t); break;
10399 case 10400: esalt_size = sizeof (pdf_t); break;
10400 case 10410: esalt_size = sizeof (pdf_t); break;
10401 case 10420: esalt_size = sizeof (pdf_t); break;
10402 case 10500: esalt_size = sizeof (pdf_t); break;
10403 case 10600: esalt_size = sizeof (pdf_t); break;
10404 case 10700: esalt_size = sizeof (pdf_t); break;
10405 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10406 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10407 case 11400: esalt_size = sizeof (sip_t); break;
10408 case 11600: esalt_size = sizeof (seven_zip_t); break;
10409 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10410 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10411 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10412 case 13000: esalt_size = sizeof (rar5_t); break;
10413 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10414 case 13400: esalt_size = sizeof (keepass_t); break;
10415 }
10416
10417 data.esalt_size = esalt_size;
10418
10419 /**
10420 * choose dictionary parser
10421 */
10422
10423 if (hash_type == HASH_TYPE_LM)
10424 {
10425 get_next_word_func = get_next_word_lm;
10426 }
10427 else if (opts_type & OPTS_TYPE_PT_UPPER)
10428 {
10429 get_next_word_func = get_next_word_uc;
10430 }
10431 else
10432 {
10433 get_next_word_func = get_next_word_std;
10434 }
10435
10436 /**
10437 * dictstat
10438 */
10439
10440 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10441
10442 #ifdef _POSIX
10443 size_t dictstat_nmemb = 0;
10444 #endif
10445
10446 #ifdef _WIN
10447 uint dictstat_nmemb = 0;
10448 #endif
10449
10450 char dictstat[256] = { 0 };
10451
10452 FILE *dictstat_fp = NULL;
10453
10454 if (keyspace == 0)
10455 {
10456 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
10457
10458 dictstat_fp = fopen (dictstat, "rb");
10459
10460 if (dictstat_fp)
10461 {
10462 #ifdef _POSIX
10463 struct stat tmpstat;
10464
10465 fstat (fileno (dictstat_fp), &tmpstat);
10466 #endif
10467
10468 #ifdef _WIN
10469 struct stat64 tmpstat;
10470
10471 _fstat64 (fileno (dictstat_fp), &tmpstat);
10472 #endif
10473
10474 if (tmpstat.st_mtime < COMPTIME)
10475 {
10476 /* with v0.15 the format changed so we have to ensure user is using a good version
10477 since there is no version-header in the dictstat file */
10478
10479 fclose (dictstat_fp);
10480
10481 unlink (dictstat);
10482 }
10483 else
10484 {
10485 while (!feof (dictstat_fp))
10486 {
10487 dictstat_t d;
10488
10489 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10490
10491 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10492
10493 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10494 {
10495 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10496
10497 return -1;
10498 }
10499 }
10500
10501 fclose (dictstat_fp);
10502 }
10503 }
10504 }
10505
10506 /**
10507 * potfile
10508 */
10509
10510 char potfile[256] = { 0 };
10511
10512 if (potfile_path == NULL)
10513 {
10514 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
10515 }
10516 else
10517 {
10518 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
10519 }
10520
10521 data.pot_fp = NULL;
10522
10523 FILE *out_fp = NULL;
10524 FILE *pot_fp = NULL;
10525
10526 if (show == 1 || left == 1)
10527 {
10528 pot_fp = fopen (potfile, "rb");
10529
10530 if (pot_fp == NULL)
10531 {
10532 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10533
10534 return (-1);
10535 }
10536
10537 if (outfile != NULL)
10538 {
10539 if ((out_fp = fopen (outfile, "ab")) == NULL)
10540 {
10541 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10542
10543 fclose (pot_fp);
10544
10545 return (-1);
10546 }
10547 }
10548 else
10549 {
10550 out_fp = stdout;
10551 }
10552 }
10553 else
10554 {
10555 if (potfile_disable == 0)
10556 {
10557 pot_fp = fopen (potfile, "ab");
10558
10559 if (pot_fp == NULL)
10560 {
10561 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10562
10563 return (-1);
10564 }
10565
10566 data.pot_fp = pot_fp;
10567 }
10568 }
10569
10570 pot_t *pot = NULL;
10571
10572 uint pot_cnt = 0;
10573 uint pot_avail = 0;
10574
10575 if (show == 1 || left == 1)
10576 {
10577 SUPPRESS_OUTPUT = 1;
10578
10579 pot_avail = count_lines (pot_fp);
10580
10581 rewind (pot_fp);
10582
10583 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10584
10585 uint pot_hashes_avail = 0;
10586
10587 uint line_num = 0;
10588
10589 char *line_buf = (char *) mymalloc (HCBUFSIZ);
10590
10591 while (!feof (pot_fp))
10592 {
10593 line_num++;
10594
10595 int line_len = fgetl (pot_fp, line_buf);
10596
10597 if (line_len == 0) continue;
10598
10599 char *plain_buf = line_buf + line_len;
10600
10601 pot_t *pot_ptr = &pot[pot_cnt];
10602
10603 hash_t *hashes_buf = &pot_ptr->hash;
10604
10605 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10606 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10607
10608 if (pot_cnt == pot_hashes_avail)
10609 {
10610 uint pos = 0;
10611
10612 for (pos = 0; pos < INCR_POT; pos++)
10613 {
10614 if ((pot_cnt + pos) >= pot_avail) break;
10615
10616 pot_t *tmp_pot = &pot[pot_cnt + pos];
10617
10618 hash_t *tmp_hash = &tmp_pot->hash;
10619
10620 tmp_hash->digest = mymalloc (dgst_size);
10621
10622 if (isSalted)
10623 {
10624 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10625 }
10626
10627 if (esalt_size)
10628 {
10629 tmp_hash->esalt = mymalloc (esalt_size);
10630 }
10631
10632 pot_hashes_avail++;
10633 }
10634 }
10635
10636 int plain_len = 0;
10637
10638 int parser_status;
10639
10640 int iter = MAX_CUT_TRIES;
10641
10642 do
10643 {
10644 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10645 {
10646 if (line_buf[i] == ':')
10647 {
10648 line_len--;
10649
10650 break;
10651 }
10652 }
10653
10654 if (data.hash_mode != 2500)
10655 {
10656 parser_status = parse_func (line_buf, line_len, hashes_buf);
10657 }
10658 else
10659 {
10660 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10661
10662 if (line_len > max_salt_size)
10663 {
10664 parser_status = PARSER_GLOBAL_LENGTH;
10665 }
10666 else
10667 {
10668 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10669
10670 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10671
10672 hashes_buf->salt->salt_len = line_len;
10673
10674 parser_status = PARSER_OK;
10675 }
10676 }
10677
10678 // if NOT parsed without error, we add the ":" to the plain
10679
10680 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10681 {
10682 plain_len++;
10683 plain_buf--;
10684 }
10685
10686 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10687
10688 if (parser_status < PARSER_GLOBAL_ZERO)
10689 {
10690 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10691
10692 continue;
10693 }
10694
10695 if (plain_len >= 255) continue;
10696
10697 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10698
10699 pot_ptr->plain_len = plain_len;
10700
10701 pot_cnt++;
10702 }
10703
10704 myfree (line_buf);
10705
10706 fclose (pot_fp);
10707
10708 SUPPRESS_OUTPUT = 0;
10709
10710 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10711 }
10712
10713 /**
10714 * word len
10715 */
10716
10717 uint pw_min = PW_MIN;
10718 uint pw_max = PW_MAX;
10719
10720 switch (hash_mode)
10721 {
10722 case 125: if (pw_max > 32) pw_max = 32;
10723 break;
10724 case 400: if (pw_max > 40) pw_max = 40;
10725 break;
10726 case 500: if (pw_max > 16) pw_max = 16;
10727 break;
10728 case 1500: if (pw_max > 8) pw_max = 8;
10729 break;
10730 case 1600: if (pw_max > 16) pw_max = 16;
10731 break;
10732 case 1800: if (pw_max > 16) pw_max = 16;
10733 break;
10734 case 2100: if (pw_max > 16) pw_max = 16;
10735 break;
10736 case 2500: if (pw_min < 8) pw_min = 8;
10737 break;
10738 case 3000: if (pw_max > 7) pw_max = 7;
10739 break;
10740 case 5200: if (pw_max > 24) pw_max = 24;
10741 break;
10742 case 5800: if (pw_max > 16) pw_max = 16;
10743 break;
10744 case 6300: if (pw_max > 16) pw_max = 16;
10745 break;
10746 case 7400: if (pw_max > 16) pw_max = 16;
10747 break;
10748 case 7900: if (pw_max > 48) pw_max = 48;
10749 break;
10750 case 8500: if (pw_max > 8) pw_max = 8;
10751 break;
10752 case 8600: if (pw_max > 16) pw_max = 16;
10753 break;
10754 case 9710: pw_min = 5;
10755 pw_max = 5;
10756 break;
10757 case 9810: pw_min = 5;
10758 pw_max = 5;
10759 break;
10760 case 10410: pw_min = 5;
10761 pw_max = 5;
10762 break;
10763 case 10300: if (pw_max < 3) pw_min = 3;
10764 if (pw_max > 40) pw_max = 40;
10765 break;
10766 case 10500: if (pw_max < 3) pw_min = 3;
10767 if (pw_max > 40) pw_max = 40;
10768 break;
10769 case 10700: if (pw_max > 16) pw_max = 16;
10770 break;
10771 case 11300: if (pw_max > 40) pw_max = 40;
10772 break;
10773 case 12500: if (pw_max > 20) pw_max = 20;
10774 break;
10775 case 12800: if (pw_max > 24) pw_max = 24;
10776 break;
10777 }
10778
10779 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10780 {
10781 switch (attack_kern)
10782 {
10783 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10784 break;
10785 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10786 break;
10787 }
10788 }
10789
10790 /**
10791 * charsets : keep them together for more easy maintainnce
10792 */
10793
10794 cs_t mp_sys[6] = { { { 0 }, 0 } };
10795 cs_t mp_usr[4] = { { { 0 }, 0 } };
10796
10797 mp_setup_sys (mp_sys);
10798
10799 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10800 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10801 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10802 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10803
10804 /**
10805 * load hashes, part I: find input mode, count hashes
10806 */
10807
10808 uint hashlist_mode = 0;
10809 uint hashlist_format = HLFMT_HASHCAT;
10810
10811 uint hashes_avail = 0;
10812
10813 if (benchmark == 0)
10814 {
10815 struct stat f;
10816
10817 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10818
10819 if ((hash_mode == 2500) ||
10820 (hash_mode == 5200) ||
10821 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10822 (hash_mode == 9000))
10823 {
10824 hashlist_mode = HL_MODE_ARG;
10825
10826 char *hashfile = myargv[optind];
10827
10828 data.hashfile = hashfile;
10829
10830 logfile_top_var_string ("target", hashfile);
10831 }
10832
10833 if (hashlist_mode == HL_MODE_ARG)
10834 {
10835 if (hash_mode == 2500)
10836 {
10837 struct stat st;
10838
10839 if (stat (data.hashfile, &st) == -1)
10840 {
10841 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10842
10843 return (-1);
10844 }
10845
10846 hashes_avail = st.st_size / sizeof (hccap_t);
10847 }
10848 else
10849 {
10850 hashes_avail = 1;
10851 }
10852 }
10853 else if (hashlist_mode == HL_MODE_FILE)
10854 {
10855 char *hashfile = myargv[optind];
10856
10857 data.hashfile = hashfile;
10858
10859 logfile_top_var_string ("target", hashfile);
10860
10861 FILE *fp = NULL;
10862
10863 if ((fp = fopen (hashfile, "rb")) == NULL)
10864 {
10865 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10866
10867 return (-1);
10868 }
10869
10870 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10871
10872 hashes_avail = count_lines (fp);
10873
10874 rewind (fp);
10875
10876 if (hashes_avail == 0)
10877 {
10878 log_error ("ERROR: hashfile is empty or corrupt");
10879
10880 fclose (fp);
10881
10882 return (-1);
10883 }
10884
10885 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10886
10887 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10888 {
10889 log_error ("ERROR: remove not supported in native hashfile-format mode");
10890
10891 fclose (fp);
10892
10893 return (-1);
10894 }
10895
10896 fclose (fp);
10897 }
10898 }
10899 else
10900 {
10901 hashlist_mode = HL_MODE_ARG;
10902
10903 hashes_avail = 1;
10904 }
10905
10906 if (hash_mode == 3000) hashes_avail *= 2;
10907
10908 data.hashlist_mode = hashlist_mode;
10909 data.hashlist_format = hashlist_format;
10910
10911 logfile_top_uint (hashlist_mode);
10912 logfile_top_uint (hashlist_format);
10913
10914 /**
10915 * load hashes, part II: allocate required memory, set pointers
10916 */
10917
10918 hash_t *hashes_buf = NULL;
10919 void *digests_buf = NULL;
10920 salt_t *salts_buf = NULL;
10921 void *esalts_buf = NULL;
10922
10923 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10924
10925 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10926
10927 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10928 {
10929 u32 hash_pos;
10930
10931 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10932 {
10933 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10934
10935 hashes_buf[hash_pos].hash_info = hash_info;
10936
10937 if (username && (remove || show || left))
10938 {
10939 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10940 }
10941
10942 if (benchmark)
10943 {
10944 hash_info->orighash = (char *) mymalloc (256);
10945 }
10946 }
10947 }
10948
10949 if (isSalted)
10950 {
10951 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10952
10953 if (esalt_size)
10954 {
10955 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10956 }
10957 }
10958 else
10959 {
10960 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10961 }
10962
10963 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10964 {
10965 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10966
10967 if (isSalted)
10968 {
10969 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10970
10971 if (esalt_size)
10972 {
10973 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10974 }
10975 }
10976 else
10977 {
10978 hashes_buf[hash_pos].salt = &salts_buf[0];
10979 }
10980 }
10981
10982 /**
10983 * load hashes, part III: parse hashes or generate them if benchmark
10984 */
10985
10986 uint hashes_cnt = 0;
10987
10988 if (benchmark == 0)
10989 {
10990 if (keyspace == 1)
10991 {
10992 // useless to read hash file for keyspace, cheat a little bit w/ optind
10993 }
10994 else if (hashes_avail == 0)
10995 {
10996 }
10997 else if (hashlist_mode == HL_MODE_ARG)
10998 {
10999 char *input_buf = myargv[optind];
11000
11001 uint input_len = strlen (input_buf);
11002
11003 logfile_top_var_string ("target", input_buf);
11004
11005 char *hash_buf = NULL;
11006 int hash_len = 0;
11007
11008 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11009
11010 bool hash_fmt_error = 0;
11011
11012 if (hash_len < 1) hash_fmt_error = 1;
11013 if (hash_buf == NULL) hash_fmt_error = 1;
11014
11015 if (hash_fmt_error)
11016 {
11017 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11018 }
11019 else
11020 {
11021 if (opts_type & OPTS_TYPE_HASH_COPY)
11022 {
11023 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11024
11025 hash_info_tmp->orighash = mystrdup (hash_buf);
11026 }
11027
11028 if (isSalted)
11029 {
11030 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11031 }
11032
11033 int parser_status = PARSER_OK;
11034
11035 if (hash_mode == 2500)
11036 {
11037 if (hash_len == 0)
11038 {
11039 log_error ("ERROR: hccap file not specified");
11040
11041 return (-1);
11042 }
11043
11044 hashlist_mode = HL_MODE_FILE;
11045
11046 data.hashlist_mode = hashlist_mode;
11047
11048 FILE *fp = fopen (hash_buf, "rb");
11049
11050 if (fp == NULL)
11051 {
11052 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11053
11054 return (-1);
11055 }
11056
11057 if (hashes_avail < 1)
11058 {
11059 log_error ("ERROR: hccap file is empty or corrupt");
11060
11061 fclose (fp);
11062
11063 return (-1);
11064 }
11065
11066 uint hccap_size = sizeof (hccap_t);
11067
11068 char *in = (char *) mymalloc (hccap_size);
11069
11070 while (!feof (fp))
11071 {
11072 int n = fread (in, hccap_size, 1, fp);
11073
11074 if (n != 1)
11075 {
11076 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11077
11078 break;
11079 }
11080
11081 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11082
11083 if (parser_status != PARSER_OK)
11084 {
11085 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11086
11087 continue;
11088 }
11089
11090 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11091
11092 if ((show == 1) || (left == 1))
11093 {
11094 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11095
11096 char *salt_ptr = (char *) tmp_salt->salt_buf;
11097
11098 int cur_pos = tmp_salt->salt_len;
11099 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11100
11101 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11102
11103 // do the appending task
11104
11105 snprintf (salt_ptr + cur_pos,
11106 rem_len,
11107 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11108 wpa->orig_mac1[0],
11109 wpa->orig_mac1[1],
11110 wpa->orig_mac1[2],
11111 wpa->orig_mac1[3],
11112 wpa->orig_mac1[4],
11113 wpa->orig_mac1[5],
11114 wpa->orig_mac2[0],
11115 wpa->orig_mac2[1],
11116 wpa->orig_mac2[2],
11117 wpa->orig_mac2[3],
11118 wpa->orig_mac2[4],
11119 wpa->orig_mac2[5]);
11120
11121 // memset () the remaining part of the salt
11122
11123 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11124 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11125
11126 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11127
11128 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11129 }
11130
11131 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);
11132 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);
11133
11134 hashes_cnt++;
11135 }
11136
11137 fclose (fp);
11138
11139 myfree (in);
11140 }
11141 else if (hash_mode == 3000)
11142 {
11143 if (hash_len == 32)
11144 {
11145 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11146
11147 hash_t *lm_hash_left = NULL;
11148
11149 if (parser_status == PARSER_OK)
11150 {
11151 lm_hash_left = &hashes_buf[hashes_cnt];
11152
11153 hashes_cnt++;
11154 }
11155 else
11156 {
11157 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11158 }
11159
11160 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11161
11162 hash_t *lm_hash_right = NULL;
11163
11164 if (parser_status == PARSER_OK)
11165 {
11166 lm_hash_right = &hashes_buf[hashes_cnt];
11167
11168 hashes_cnt++;
11169 }
11170 else
11171 {
11172 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11173 }
11174
11175 // show / left
11176
11177 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11178 {
11179 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);
11180 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);
11181 }
11182 }
11183 else
11184 {
11185 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11186
11187 if (parser_status == PARSER_OK)
11188 {
11189 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11190 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11191 }
11192
11193 if (parser_status == PARSER_OK)
11194 {
11195 hashes_cnt++;
11196 }
11197 else
11198 {
11199 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11200 }
11201 }
11202 }
11203 else
11204 {
11205 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11206
11207 if (parser_status == PARSER_OK)
11208 {
11209 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11210 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11211 }
11212
11213 if (parser_status == PARSER_OK)
11214 {
11215 hashes_cnt++;
11216 }
11217 else
11218 {
11219 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11220 }
11221 }
11222 }
11223 }
11224 else if (hashlist_mode == HL_MODE_FILE)
11225 {
11226 char *hashfile = data.hashfile;
11227
11228 FILE *fp;
11229
11230 if ((fp = fopen (hashfile, "rb")) == NULL)
11231 {
11232 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11233
11234 return (-1);
11235 }
11236
11237 uint line_num = 0;
11238
11239 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11240
11241 while (!feof (fp))
11242 {
11243 line_num++;
11244
11245 int line_len = fgetl (fp, line_buf);
11246
11247 if (line_len == 0) continue;
11248
11249 char *hash_buf = NULL;
11250 int hash_len = 0;
11251
11252 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11253
11254 bool hash_fmt_error = 0;
11255
11256 if (hash_len < 1) hash_fmt_error = 1;
11257 if (hash_buf == NULL) hash_fmt_error = 1;
11258
11259 if (hash_fmt_error)
11260 {
11261 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11262
11263 continue;
11264 }
11265
11266 if (username)
11267 {
11268 char *user_buf = NULL;
11269 int user_len = 0;
11270
11271 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11272
11273 if (remove || show)
11274 {
11275 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11276
11277 *user = (user_t *) mymalloc (sizeof (user_t));
11278
11279 user_t *user_ptr = *user;
11280
11281 if (user_buf != NULL)
11282 {
11283 user_ptr->user_name = mystrdup (user_buf);
11284 }
11285 else
11286 {
11287 user_ptr->user_name = mystrdup ("");
11288 }
11289
11290 user_ptr->user_len = user_len;
11291 }
11292 }
11293
11294 if (opts_type & OPTS_TYPE_HASH_COPY)
11295 {
11296 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11297
11298 hash_info_tmp->orighash = mystrdup (hash_buf);
11299 }
11300
11301 if (isSalted)
11302 {
11303 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11304 }
11305
11306 if (hash_mode == 3000)
11307 {
11308 if (hash_len == 32)
11309 {
11310 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11311
11312 if (parser_status < PARSER_GLOBAL_ZERO)
11313 {
11314 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11315
11316 continue;
11317 }
11318
11319 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11320
11321 hashes_cnt++;
11322
11323 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11324
11325 if (parser_status < PARSER_GLOBAL_ZERO)
11326 {
11327 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11328
11329 continue;
11330 }
11331
11332 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11333
11334 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);
11335
11336 hashes_cnt++;
11337
11338 // show / left
11339
11340 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);
11341 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);
11342 }
11343 else
11344 {
11345 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11346
11347 if (parser_status < PARSER_GLOBAL_ZERO)
11348 {
11349 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11350
11351 continue;
11352 }
11353
11354 if (data.quiet == 0) if ((hashes_cnt % 0x20000) == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_cnt, hashes_avail, ((float) hashes_cnt / hashes_avail) * 100);
11355
11356 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11357 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11358
11359 hashes_cnt++;
11360 }
11361 }
11362 else
11363 {
11364 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11365
11366 if (parser_status < PARSER_GLOBAL_ZERO)
11367 {
11368 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11369
11370 continue;
11371 }
11372
11373 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);
11374
11375 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11376 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11377
11378 hashes_cnt++;
11379 }
11380 }
11381
11382 myfree (line_buf);
11383
11384 fclose (fp);
11385
11386 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11387
11388 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11389 }
11390 }
11391 else
11392 {
11393 if (isSalted)
11394 {
11395 hashes_buf[0].salt->salt_len = 8;
11396
11397 // special salt handling
11398
11399 switch (hash_mode)
11400 {
11401 case 1500: hashes_buf[0].salt->salt_len = 2;
11402 break;
11403 case 1731: hashes_buf[0].salt->salt_len = 4;
11404 break;
11405 case 2410: hashes_buf[0].salt->salt_len = 4;
11406 break;
11407 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11408 break;
11409 case 3100: hashes_buf[0].salt->salt_len = 1;
11410 break;
11411 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11412 break;
11413 case 5800: hashes_buf[0].salt->salt_len = 16;
11414 break;
11415 case 6800: hashes_buf[0].salt->salt_len = 32;
11416 break;
11417 case 8400: hashes_buf[0].salt->salt_len = 40;
11418 break;
11419 case 8800: hashes_buf[0].salt->salt_len = 16;
11420 break;
11421 case 8900: hashes_buf[0].salt->salt_len = 16;
11422 hashes_buf[0].salt->scrypt_N = 1024;
11423 hashes_buf[0].salt->scrypt_r = 1;
11424 hashes_buf[0].salt->scrypt_p = 1;
11425 break;
11426 case 9100: hashes_buf[0].salt->salt_len = 16;
11427 break;
11428 case 9300: hashes_buf[0].salt->salt_len = 14;
11429 hashes_buf[0].salt->scrypt_N = 16384;
11430 hashes_buf[0].salt->scrypt_r = 1;
11431 hashes_buf[0].salt->scrypt_p = 1;
11432 break;
11433 case 9400: hashes_buf[0].salt->salt_len = 16;
11434 break;
11435 case 9500: hashes_buf[0].salt->salt_len = 16;
11436 break;
11437 case 9600: hashes_buf[0].salt->salt_len = 16;
11438 break;
11439 case 9700: hashes_buf[0].salt->salt_len = 16;
11440 break;
11441 case 9710: hashes_buf[0].salt->salt_len = 16;
11442 break;
11443 case 9720: hashes_buf[0].salt->salt_len = 16;
11444 break;
11445 case 9800: hashes_buf[0].salt->salt_len = 16;
11446 break;
11447 case 9810: hashes_buf[0].salt->salt_len = 16;
11448 break;
11449 case 9820: hashes_buf[0].salt->salt_len = 16;
11450 break;
11451 case 10300: hashes_buf[0].salt->salt_len = 12;
11452 break;
11453 case 11500: hashes_buf[0].salt->salt_len = 4;
11454 break;
11455 case 11600: hashes_buf[0].salt->salt_len = 4;
11456 break;
11457 case 12400: hashes_buf[0].salt->salt_len = 4;
11458 break;
11459 case 12500: hashes_buf[0].salt->salt_len = 8;
11460 break;
11461 case 12600: hashes_buf[0].salt->salt_len = 64;
11462 break;
11463 }
11464
11465 // special esalt handling
11466
11467 switch (hash_mode)
11468 {
11469 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11470 break;
11471 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11472 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11473 break;
11474 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11475 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11476 break;
11477 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11478 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11479 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11480 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11481 break;
11482 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11483 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11484 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11485 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11486 break;
11487 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11488 break;
11489 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11490 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11491 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11492 break;
11493 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11494 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11495 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11496 break;
11497 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11498 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11499 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11500 break;
11501 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11502 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11503 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11504 break;
11505 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11506 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11507 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11508 break;
11509 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11510 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11511 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11512 break;
11513 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11514 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11515 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11516 break;
11517 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
11518 break;
11519 }
11520 }
11521
11522 // set hashfile
11523
11524 switch (hash_mode)
11525 {
11526 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11527 break;
11528 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11529 break;
11530 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11531 break;
11532 case 6211: data.hashfile = mystrdup ("hashcat.tc");
11533 break;
11534 case 6212: data.hashfile = mystrdup ("hashcat.tc");
11535 break;
11536 case 6213: data.hashfile = mystrdup ("hashcat.tc");
11537 break;
11538 case 6221: data.hashfile = mystrdup ("hashcat.tc");
11539 break;
11540 case 6222: data.hashfile = mystrdup ("hashcat.tc");
11541 break;
11542 case 6223: data.hashfile = mystrdup ("hashcat.tc");
11543 break;
11544 case 6231: data.hashfile = mystrdup ("hashcat.tc");
11545 break;
11546 case 6232: data.hashfile = mystrdup ("hashcat.tc");
11547 break;
11548 case 6233: data.hashfile = mystrdup ("hashcat.tc");
11549 break;
11550 case 6241: data.hashfile = mystrdup ("hashcat.tc");
11551 break;
11552 case 6242: data.hashfile = mystrdup ("hashcat.tc");
11553 break;
11554 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11555 break;
11556 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11557 break;
11558 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11559 break;
11560 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11561 break;
11562 }
11563
11564 // set default iterations
11565
11566 switch (hash_mode)
11567 {
11568 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11569 break;
11570 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11571 break;
11572 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11573 break;
11574 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11575 break;
11576 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11577 break;
11578 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11579 break;
11580 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11581 break;
11582 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11583 break;
11584 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11585 break;
11586 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11587 break;
11588 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11589 break;
11590 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11591 break;
11592 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11593 break;
11594 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11595 break;
11596 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11597 break;
11598 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11599 break;
11600 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11601 break;
11602 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11603 break;
11604 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11605 break;
11606 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11607 break;
11608 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11609 break;
11610 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11611 break;
11612 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11613 break;
11614 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11615 break;
11616 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11617 break;
11618 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11619 break;
11620 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11621 break;
11622 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11623 break;
11624 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11625 break;
11626 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11627 break;
11628 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11629 break;
11630 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11631 break;
11632 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11633 break;
11634 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11635 break;
11636 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11637 break;
11638 case 8900: hashes_buf[0].salt->salt_iter = 1;
11639 break;
11640 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11641 break;
11642 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11643 break;
11644 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11645 break;
11646 case 9300: hashes_buf[0].salt->salt_iter = 1;
11647 break;
11648 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11649 break;
11650 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11651 break;
11652 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11653 break;
11654 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11655 break;
11656 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11657 break;
11658 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11659 break;
11660 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11661 break;
11662 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11663 break;
11664 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11665 break;
11666 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11667 break;
11668 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11669 break;
11670 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11671 break;
11672 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11673 break;
11674 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11675 break;
11676 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11677 break;
11678 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11679 break;
11680 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11681 break;
11682 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11683 break;
11684 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11685 break;
11686 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11687 break;
11688 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11689 break;
11690 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
11691 break;
11692 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
11693 break;
11694 }
11695
11696 hashes_cnt = 1;
11697 }
11698
11699 if (show == 1 || left == 1)
11700 {
11701 for (uint i = 0; i < pot_cnt; i++)
11702 {
11703 pot_t *pot_ptr = &pot[i];
11704
11705 hash_t *hashes_buf = &pot_ptr->hash;
11706
11707 local_free (hashes_buf->digest);
11708
11709 if (isSalted)
11710 {
11711 local_free (hashes_buf->salt);
11712 }
11713 }
11714
11715 local_free (pot);
11716
11717 if (data.quiet == 0) log_info_nn ("");
11718
11719 return (0);
11720 }
11721
11722 if (keyspace == 0)
11723 {
11724 if (hashes_cnt == 0)
11725 {
11726 log_error ("ERROR: No hashes loaded");
11727
11728 return (-1);
11729 }
11730 }
11731
11732 /**
11733 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11734 */
11735
11736 if (data.outfile != NULL)
11737 {
11738 if (data.hashfile != NULL)
11739 {
11740 #ifdef _POSIX
11741 struct stat tmpstat_outfile;
11742 struct stat tmpstat_hashfile;
11743 #endif
11744
11745 #ifdef _WIN
11746 struct stat64 tmpstat_outfile;
11747 struct stat64 tmpstat_hashfile;
11748 #endif
11749
11750 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11751
11752 if (tmp_outfile_fp)
11753 {
11754 #ifdef _POSIX
11755 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11756 #endif
11757
11758 #ifdef _WIN
11759 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11760 #endif
11761
11762 fclose (tmp_outfile_fp);
11763 }
11764
11765 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11766
11767 if (tmp_hashfile_fp)
11768 {
11769 #ifdef _POSIX
11770 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11771 #endif
11772
11773 #ifdef _WIN
11774 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11775 #endif
11776
11777 fclose (tmp_hashfile_fp);
11778 }
11779
11780 if (tmp_outfile_fp && tmp_outfile_fp)
11781 {
11782 tmpstat_outfile.st_mode = 0;
11783 tmpstat_outfile.st_nlink = 0;
11784 tmpstat_outfile.st_uid = 0;
11785 tmpstat_outfile.st_gid = 0;
11786 tmpstat_outfile.st_rdev = 0;
11787 tmpstat_outfile.st_atime = 0;
11788
11789 tmpstat_hashfile.st_mode = 0;
11790 tmpstat_hashfile.st_nlink = 0;
11791 tmpstat_hashfile.st_uid = 0;
11792 tmpstat_hashfile.st_gid = 0;
11793 tmpstat_hashfile.st_rdev = 0;
11794 tmpstat_hashfile.st_atime = 0;
11795
11796 #ifdef _POSIX
11797 tmpstat_outfile.st_blksize = 0;
11798 tmpstat_outfile.st_blocks = 0;
11799
11800 tmpstat_hashfile.st_blksize = 0;
11801 tmpstat_hashfile.st_blocks = 0;
11802 #endif
11803
11804 #ifdef _POSIX
11805 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11806 {
11807 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11808
11809 return (-1);
11810 }
11811 #endif
11812
11813 #ifdef _WIN
11814 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11815 {
11816 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11817
11818 return (-1);
11819 }
11820 #endif
11821 }
11822 }
11823 }
11824
11825 /**
11826 * Remove duplicates
11827 */
11828
11829 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11830
11831 if (isSalted)
11832 {
11833 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11834 }
11835 else
11836 {
11837 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11838 }
11839
11840 uint hashes_cnt_orig = hashes_cnt;
11841
11842 hashes_cnt = 1;
11843
11844 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11845 {
11846 if (isSalted)
11847 {
11848 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11849 {
11850 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11851 }
11852 }
11853 else
11854 {
11855 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11856 }
11857
11858 if (hashes_pos > hashes_cnt)
11859 {
11860 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11861 }
11862
11863 hashes_cnt++;
11864 }
11865
11866 /**
11867 * Potfile removes
11868 */
11869
11870 uint potfile_remove_cracks = 0;
11871
11872 if (potfile_disable == 0)
11873 {
11874 hash_t hash_buf;
11875
11876 hash_buf.digest = mymalloc (dgst_size);
11877 hash_buf.salt = NULL;
11878 hash_buf.esalt = NULL;
11879 hash_buf.hash_info = NULL;
11880 hash_buf.cracked = 0;
11881
11882 if (isSalted)
11883 {
11884 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11885 }
11886
11887 if (esalt_size)
11888 {
11889 hash_buf.esalt = mymalloc (esalt_size);
11890 }
11891
11892 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11893
11894 // no solution for these special hash types (for instane because they use hashfile in output etc)
11895 if ((hash_mode != 5200) &&
11896 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11897 (hash_mode != 9000))
11898 {
11899 FILE *fp = fopen (potfile, "rb");
11900
11901 if (fp != NULL)
11902 {
11903 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11904
11905 // to be safe work with a copy (because of line_len loop, i etc)
11906 // moved up here because it's easier to handle continue case
11907 // it's just 64kb
11908
11909 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
11910
11911 while (!feof (fp))
11912 {
11913 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
11914
11915 if (ptr == NULL) break;
11916
11917 int line_len = strlen (line_buf);
11918
11919 if (line_len == 0) continue;
11920
11921 int iter = MAX_CUT_TRIES;
11922
11923 for (int i = line_len - 1; i && iter; i--, line_len--)
11924 {
11925 if (line_buf[i] != ':') continue;
11926
11927 if (isSalted)
11928 {
11929 memset (hash_buf.salt, 0, sizeof (salt_t));
11930 }
11931
11932 hash_t *found = NULL;
11933
11934 if (hash_mode == 6800)
11935 {
11936 if (i < 64) // 64 = 16 * uint in salt_buf[]
11937 {
11938 // manipulate salt_buf
11939 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11940
11941 hash_buf.salt->salt_len = i;
11942
11943 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11944 }
11945 }
11946 else if (hash_mode == 2500)
11947 {
11948 if (i < 64) // 64 = 16 * uint in salt_buf[]
11949 {
11950 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11951 // manipulate salt_buf
11952
11953 memcpy (line_buf_cpy, line_buf, i);
11954
11955 char *mac2_pos = strrchr (line_buf_cpy, ':');
11956
11957 if (mac2_pos == NULL) continue;
11958
11959 mac2_pos[0] = 0;
11960 mac2_pos++;
11961
11962 if (strlen (mac2_pos) != 12) continue;
11963
11964 char *mac1_pos = strrchr (line_buf_cpy, ':');
11965
11966 if (mac1_pos == NULL) continue;
11967
11968 mac1_pos[0] = 0;
11969 mac1_pos++;
11970
11971 if (strlen (mac1_pos) != 12) continue;
11972
11973 uint essid_length = mac1_pos - line_buf_cpy - 1;
11974
11975 // here we need the ESSID
11976 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11977
11978 hash_buf.salt->salt_len = essid_length;
11979
11980 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11981
11982 if (found)
11983 {
11984 wpa_t *wpa = (wpa_t *) found->esalt;
11985
11986 // compare hex string(s) vs binary MAC address(es)
11987
11988 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11989 {
11990 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
11991 {
11992 found = NULL;
11993
11994 break;
11995 }
11996 }
11997
11998 // early skip ;)
11999 if (!found) continue;
12000
12001 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12002 {
12003 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
12004 {
12005 found = NULL;
12006
12007 break;
12008 }
12009 }
12010 }
12011 }
12012 }
12013 else
12014 {
12015 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12016
12017 if (parser_status == PARSER_OK)
12018 {
12019 if (isSalted)
12020 {
12021 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12022 }
12023 else
12024 {
12025 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12026 }
12027 }
12028 }
12029
12030 if (found == NULL) continue;
12031
12032 if (!found->cracked) potfile_remove_cracks++;
12033
12034 found->cracked = 1;
12035
12036 if (found) break;
12037
12038 iter--;
12039 }
12040 }
12041
12042 myfree (line_buf_cpy);
12043
12044 myfree (line_buf);
12045
12046 fclose (fp);
12047 }
12048 }
12049
12050 if (esalt_size)
12051 {
12052 local_free (hash_buf.esalt);
12053 }
12054
12055 if (isSalted)
12056 {
12057 local_free (hash_buf.salt);
12058 }
12059
12060 local_free (hash_buf.digest);
12061 }
12062
12063 /**
12064 * Now generate all the buffers required for later
12065 */
12066
12067 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12068
12069 salt_t *salts_buf_new = NULL;
12070 void *esalts_buf_new = NULL;
12071
12072 if (isSalted)
12073 {
12074 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12075
12076 if (esalt_size)
12077 {
12078 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12079 }
12080 }
12081 else
12082 {
12083 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12084 }
12085
12086 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12087
12088 uint digests_cnt = hashes_cnt;
12089 uint digests_done = 0;
12090
12091 uint size_digests = digests_cnt * dgst_size;
12092 uint size_shown = digests_cnt * sizeof (uint);
12093
12094 uint *digests_shown = (uint *) mymalloc (size_shown);
12095 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12096
12097 uint salts_cnt = 0;
12098 uint salts_done = 0;
12099
12100 hashinfo_t **hash_info = NULL;
12101
12102 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12103 {
12104 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12105
12106 if (username && (remove || show))
12107 {
12108 uint user_pos;
12109
12110 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12111 {
12112 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12113
12114 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12115 }
12116 }
12117 }
12118
12119 uint *salts_shown = (uint *) mymalloc (size_shown);
12120
12121 salt_t *salt_buf;
12122
12123 {
12124 // copied from inner loop
12125
12126 salt_buf = &salts_buf_new[salts_cnt];
12127
12128 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12129
12130 if (esalt_size)
12131 {
12132 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12133 }
12134
12135 salt_buf->digests_cnt = 0;
12136 salt_buf->digests_done = 0;
12137 salt_buf->digests_offset = 0;
12138
12139 salts_cnt++;
12140 }
12141
12142 if (hashes_buf[0].cracked == 1)
12143 {
12144 digests_shown[0] = 1;
12145
12146 digests_done++;
12147
12148 salt_buf->digests_done++;
12149 }
12150
12151 salt_buf->digests_cnt++;
12152
12153 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12154
12155 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12156 {
12157 hash_info[0] = hashes_buf[0].hash_info;
12158 }
12159
12160 // copy from inner loop
12161
12162 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12163 {
12164 if (isSalted)
12165 {
12166 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12167 {
12168 salt_buf = &salts_buf_new[salts_cnt];
12169
12170 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12171
12172 if (esalt_size)
12173 {
12174 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12175 }
12176
12177 salt_buf->digests_cnt = 0;
12178 salt_buf->digests_done = 0;
12179 salt_buf->digests_offset = hashes_pos;
12180
12181 salts_cnt++;
12182 }
12183 }
12184
12185 if (hashes_buf[hashes_pos].cracked == 1)
12186 {
12187 digests_shown[hashes_pos] = 1;
12188
12189 digests_done++;
12190
12191 salt_buf->digests_done++;
12192 }
12193
12194 salt_buf->digests_cnt++;
12195
12196 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12197
12198 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12199 {
12200 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12201 }
12202 }
12203
12204 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12205 {
12206 salt_t *salt_buf = &salts_buf_new[salt_pos];
12207
12208 if (salt_buf->digests_done == salt_buf->digests_cnt)
12209 {
12210 salts_shown[salt_pos] = 1;
12211
12212 salts_done++;
12213 }
12214
12215 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12216 }
12217
12218 local_free (digests_buf);
12219 local_free (salts_buf);
12220 local_free (esalts_buf);
12221
12222 digests_buf = digests_buf_new;
12223 salts_buf = salts_buf_new;
12224 esalts_buf = esalts_buf_new;
12225
12226 local_free (hashes_buf);
12227
12228 /**
12229 * special modification not set from parser
12230 */
12231
12232 switch (hash_mode)
12233 {
12234 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12235 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12236 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12237 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12238 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12239 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12240 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12241 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12242 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12243 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12244 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12245 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12246 }
12247
12248 if (truecrypt_keyfiles)
12249 {
12250 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12251
12252 char *keyfiles = strdup (truecrypt_keyfiles);
12253
12254 char *keyfile = strtok (keyfiles, ",");
12255
12256 do
12257 {
12258 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12259
12260 } while ((keyfile = strtok (NULL, ",")) != NULL);
12261
12262 free (keyfiles);
12263 }
12264
12265 data.digests_cnt = digests_cnt;
12266 data.digests_done = digests_done;
12267 data.digests_buf = digests_buf;
12268 data.digests_shown = digests_shown;
12269 data.digests_shown_tmp = digests_shown_tmp;
12270
12271 data.salts_cnt = salts_cnt;
12272 data.salts_done = salts_done;
12273 data.salts_buf = salts_buf;
12274 data.salts_shown = salts_shown;
12275
12276 data.esalts_buf = esalts_buf;
12277 data.hash_info = hash_info;
12278
12279 /**
12280 * Automatic Optimizers
12281 */
12282
12283 if (salts_cnt == 1)
12284 opti_type |= OPTI_TYPE_SINGLE_SALT;
12285
12286 if (digests_cnt == 1)
12287 opti_type |= OPTI_TYPE_SINGLE_HASH;
12288
12289 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12290 opti_type |= OPTI_TYPE_NOT_ITERATED;
12291
12292 if (attack_mode == ATTACK_MODE_BF)
12293 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12294
12295 data.opti_type = opti_type;
12296
12297 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12298 {
12299 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12300 {
12301 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12302 {
12303 if (opts_type & OPTS_TYPE_ST_ADD80)
12304 {
12305 opts_type &= ~OPTS_TYPE_ST_ADD80;
12306 opts_type |= OPTS_TYPE_PT_ADD80;
12307 }
12308
12309 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12310 {
12311 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12312 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12313 }
12314
12315 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12316 {
12317 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12318 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12319 }
12320 }
12321 }
12322 }
12323
12324 /**
12325 * Some algorithm, like descrypt, can benefit from JIT compilation
12326 */
12327
12328 int force_jit_compilation = -1;
12329
12330 if (hash_mode == 8900)
12331 {
12332 force_jit_compilation = 8900;
12333 }
12334 else if (hash_mode == 9300)
12335 {
12336 force_jit_compilation = 8900;
12337 }
12338 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12339 {
12340 force_jit_compilation = 1500;
12341 }
12342
12343 /**
12344 * generate bitmap tables
12345 */
12346
12347 const uint bitmap_shift1 = 5;
12348 const uint bitmap_shift2 = 13;
12349
12350 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12351
12352 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12353 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12354 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12355 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12356 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12357 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12358 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12359 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12360
12361 uint bitmap_bits;
12362 uint bitmap_nums;
12363 uint bitmap_mask;
12364 uint bitmap_size;
12365
12366 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12367 {
12368 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12369
12370 bitmap_nums = 1 << bitmap_bits;
12371
12372 bitmap_mask = bitmap_nums - 1;
12373
12374 bitmap_size = bitmap_nums * sizeof (uint);
12375
12376 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12377
12378 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;
12379 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;
12380
12381 break;
12382 }
12383
12384 bitmap_nums = 1 << bitmap_bits;
12385
12386 bitmap_mask = bitmap_nums - 1;
12387
12388 bitmap_size = bitmap_nums * sizeof (uint);
12389
12390 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);
12391 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);
12392
12393 /**
12394 * prepare quick rule
12395 */
12396
12397 data.rule_buf_l = rule_buf_l;
12398 data.rule_buf_r = rule_buf_r;
12399
12400 int rule_len_l = (int) strlen (rule_buf_l);
12401 int rule_len_r = (int) strlen (rule_buf_r);
12402
12403 data.rule_len_l = rule_len_l;
12404 data.rule_len_r = rule_len_r;
12405
12406 /**
12407 * load rules
12408 */
12409
12410 uint *all_kernel_rules_cnt = NULL;
12411
12412 kernel_rule_t **all_kernel_rules_buf = NULL;
12413
12414 if (rp_files_cnt)
12415 {
12416 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12417
12418 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12419 }
12420
12421 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
12422
12423 int rule_len = 0;
12424
12425 for (uint i = 0; i < rp_files_cnt; i++)
12426 {
12427 uint kernel_rules_avail = 0;
12428
12429 uint kernel_rules_cnt = 0;
12430
12431 kernel_rule_t *kernel_rules_buf = NULL;
12432
12433 char *rp_file = rp_files[i];
12434
12435 char in[BLOCK_SIZE] = { 0 };
12436 char out[BLOCK_SIZE] = { 0 };
12437
12438 FILE *fp = NULL;
12439
12440 uint rule_line = 0;
12441
12442 if ((fp = fopen (rp_file, "rb")) == NULL)
12443 {
12444 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12445
12446 return (-1);
12447 }
12448
12449 while (!feof (fp))
12450 {
12451 memset (rule_buf, 0, HCBUFSIZ);
12452
12453 rule_len = fgetl (fp, rule_buf);
12454
12455 rule_line++;
12456
12457 if (rule_len == 0) continue;
12458
12459 if (rule_buf[0] == '#') continue;
12460
12461 if (kernel_rules_avail == kernel_rules_cnt)
12462 {
12463 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12464
12465 kernel_rules_avail += INCR_RULES;
12466 }
12467
12468 memset (in, 0, BLOCK_SIZE);
12469 memset (out, 0, BLOCK_SIZE);
12470
12471 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12472
12473 if (result == -1)
12474 {
12475 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12476
12477 continue;
12478 }
12479
12480 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12481 {
12482 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12483
12484 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12485
12486 continue;
12487 }
12488
12489 /* its so slow
12490 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12491 {
12492 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12493
12494 continue;
12495 }
12496 */
12497
12498 kernel_rules_cnt++;
12499 }
12500
12501 fclose (fp);
12502
12503 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12504
12505 all_kernel_rules_buf[i] = kernel_rules_buf;
12506 }
12507
12508 /**
12509 * merge rules or automatic rule generator
12510 */
12511
12512 uint kernel_rules_cnt = 0;
12513
12514 kernel_rule_t *kernel_rules_buf = NULL;
12515
12516 if (attack_mode == ATTACK_MODE_STRAIGHT)
12517 {
12518 if (rp_files_cnt)
12519 {
12520 kernel_rules_cnt = 1;
12521
12522 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12523
12524 repeats[0] = kernel_rules_cnt;
12525
12526 for (uint i = 0; i < rp_files_cnt; i++)
12527 {
12528 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12529
12530 repeats[i + 1] = kernel_rules_cnt;
12531 }
12532
12533 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12534
12535 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12536
12537 for (uint i = 0; i < kernel_rules_cnt; i++)
12538 {
12539 uint out_pos = 0;
12540
12541 kernel_rule_t *out = &kernel_rules_buf[i];
12542
12543 for (uint j = 0; j < rp_files_cnt; j++)
12544 {
12545 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12546 uint in_pos;
12547
12548 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12549
12550 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12551 {
12552 if (out_pos == RULES_MAX - 1)
12553 {
12554 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12555
12556 break;
12557 }
12558
12559 out->cmds[out_pos] = in->cmds[in_pos];
12560 }
12561 }
12562 }
12563
12564 local_free (repeats);
12565 }
12566 else if (rp_gen)
12567 {
12568 uint kernel_rules_avail = 0;
12569
12570 while (kernel_rules_cnt < rp_gen)
12571 {
12572 if (kernel_rules_avail == kernel_rules_cnt)
12573 {
12574 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12575
12576 kernel_rules_avail += INCR_RULES;
12577 }
12578
12579 memset (rule_buf, 0, HCBUFSIZ);
12580
12581 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12582
12583 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12584
12585 kernel_rules_cnt++;
12586 }
12587 }
12588 }
12589
12590 myfree (rule_buf);
12591
12592 /**
12593 * generate NOP rules
12594 */
12595
12596 if (kernel_rules_cnt == 0)
12597 {
12598 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12599
12600 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12601
12602 kernel_rules_cnt++;
12603 }
12604
12605 data.kernel_rules_cnt = kernel_rules_cnt;
12606 data.kernel_rules_buf = kernel_rules_buf;
12607
12608 /**
12609 * OpenCL platforms: detect
12610 */
12611
12612 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
12613 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
12614
12615 cl_uint platforms_cnt = 0;
12616 cl_uint platform_devices_cnt = 0;
12617
12618 if (keyspace == 0)
12619 {
12620 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12621
12622 if (platforms_cnt == 0)
12623 {
12624 log_error ("ERROR: No OpenCL compatible platform found");
12625
12626 return (-1);
12627 }
12628
12629 if (opencl_platforms_filter != (uint) -1)
12630 {
12631 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
12632
12633 if (opencl_platforms_filter > platform_cnt_mask)
12634 {
12635 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
12636
12637 return (-1);
12638 }
12639 }
12640 }
12641
12642 /**
12643 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12644 */
12645
12646 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12647 {
12648 cl_platform_id platform = platforms[platform_id];
12649
12650 char platform_vendor[INFOSZ] = { 0 };
12651
12652 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12653
12654 #ifdef HAVE_HWMON
12655 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12656 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12657 {
12658 // make sure that we do not directly control the fan for NVidia
12659
12660 gpu_temp_retain = 0;
12661
12662 data.gpu_temp_retain = gpu_temp_retain;
12663 }
12664 #endif // HAVE_NVML || HAVE_NVAPI
12665 #endif
12666 }
12667
12668 /**
12669 * OpenCL devices: simply push all devices from all platforms into the same device array
12670 */
12671
12672 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12673
12674 data.devices_param = devices_param;
12675
12676 uint devices_cnt = 0;
12677
12678 uint devices_active = 0;
12679
12680 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12681 {
12682 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12683
12684 cl_platform_id platform = platforms[platform_id];
12685
12686 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12687
12688 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12689 {
12690 size_t param_value_size = 0;
12691
12692 const uint device_id = devices_cnt;
12693
12694 hc_device_param_t *device_param = &data.devices_param[device_id];
12695
12696 device_param->device = platform_devices[platform_devices_id];
12697
12698 device_param->device_id = device_id;
12699
12700 device_param->platform_devices_id = platform_devices_id;
12701
12702 // device_type
12703
12704 cl_device_type device_type;
12705
12706 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12707
12708 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12709
12710 device_param->device_type = device_type;
12711
12712 // vendor_id
12713
12714 cl_uint vendor_id = 0;
12715
12716 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR_ID, sizeof (vendor_id), &vendor_id, NULL);
12717
12718 device_param->vendor_id = vendor_id;
12719
12720 // device_name
12721
12722 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
12723
12724 char *device_name = (char *) mymalloc (param_value_size);
12725
12726 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
12727
12728 device_param->device_name = device_name;
12729
12730 // tuning db
12731
12732 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
12733
12734 // device_version
12735
12736 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
12737
12738 char *device_version = (char *) mymalloc (param_value_size);
12739
12740 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
12741
12742 device_param->device_version = device_version;
12743
12744 // device_opencl_version
12745
12746 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
12747
12748 char *device_opencl_version = (char *) mymalloc (param_value_size);
12749
12750 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
12751
12752 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
12753
12754 myfree (device_opencl_version);
12755
12756 if (strstr (device_version, "pocl"))
12757 {
12758 // pocl returns the real vendor_id in CL_DEVICE_VENDOR_ID which causes many problems because of hms and missing amd_bfe () etc
12759 // we need to overwrite vendor_id to avoid this. maybe open pocl issue?
12760
12761 cl_uint vendor_id = VENDOR_ID_GENERIC;
12762
12763 device_param->vendor_id = vendor_id;
12764 }
12765
12766 // vector_width
12767
12768 cl_uint vector_width;
12769
12770 if (opencl_vector_width_chgd == 0)
12771 {
12772 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
12773 {
12774 if (opti_type & OPTI_TYPE_USES_BITS_64)
12775 {
12776 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
12777 }
12778 else
12779 {
12780 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12781 }
12782 }
12783 else
12784 {
12785 vector_width = (cl_uint) tuningdb_entry->vector_width;
12786 }
12787 }
12788 else
12789 {
12790 vector_width = opencl_vector_width;
12791 }
12792
12793 if (vector_width > 16) vector_width = 16;
12794
12795 device_param->vector_width = vector_width;
12796
12797 // max_compute_units
12798
12799 cl_uint device_processors;
12800
12801 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12802
12803 device_param->device_processors = device_processors;
12804
12805 // max_mem_alloc_size
12806
12807 cl_ulong device_maxmem_alloc;
12808
12809 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12810
12811 device_param->device_maxmem_alloc = device_maxmem_alloc;
12812
12813 // max_mem_alloc_size
12814
12815 cl_ulong device_global_mem;
12816
12817 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12818
12819 device_param->device_global_mem = device_global_mem;
12820
12821 // max_clock_frequency
12822
12823 cl_uint device_maxclock_frequency;
12824
12825 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12826
12827 device_param->device_maxclock_frequency = device_maxclock_frequency;
12828
12829 // skipped
12830
12831 const u32 skipped1 = ((devices_filter & (1 << device_id)) == 0);
12832 const u32 skipped2 = ((device_types_filter & (device_type)) == 0);
12833
12834 device_param->skipped = (skipped1 || skipped2);
12835
12836 // driver_version
12837 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
12838
12839 char *driver_version = (char *) mymalloc (param_value_size);
12840
12841 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
12842
12843 device_param->driver_version = driver_version;
12844
12845 // device_name_chksum
12846
12847 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12848
12849 #if __x86_64__
12850 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);
12851 #else
12852 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);
12853 #endif
12854
12855 uint device_name_digest[4] = { 0 };
12856
12857 md5_64 ((uint *) device_name_chksum, device_name_digest);
12858
12859 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
12860
12861 device_param->device_name_chksum = device_name_chksum;
12862
12863 // device_processor_cores
12864
12865 if (device_type & CL_DEVICE_TYPE_CPU)
12866 {
12867 cl_uint device_processor_cores = 1;
12868
12869 device_param->device_processor_cores = device_processor_cores;
12870 }
12871
12872 if (device_type & CL_DEVICE_TYPE_GPU)
12873 {
12874 if (vendor_id == VENDOR_ID_AMD)
12875 {
12876 cl_uint device_processor_cores = 0;
12877
12878 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12879
12880 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12881
12882 device_param->device_processor_cores = device_processor_cores;
12883 }
12884 else if (vendor_id == VENDOR_ID_NV)
12885 {
12886 cl_uint kernel_exec_timeout = 0;
12887
12888 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12889
12890 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12891
12892 device_param->kernel_exec_timeout = kernel_exec_timeout;
12893
12894 cl_uint device_processor_cores = 0;
12895
12896 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12897
12898 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12899
12900 device_param->device_processor_cores = device_processor_cores;
12901
12902 cl_uint sm_minor = 0;
12903 cl_uint sm_major = 0;
12904
12905 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12906 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12907
12908 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12909 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12910
12911 device_param->sm_minor = sm_minor;
12912 device_param->sm_major = sm_major;
12913 }
12914 else
12915 {
12916 cl_uint device_processor_cores = 1;
12917
12918 device_param->device_processor_cores = device_processor_cores;
12919 }
12920 }
12921
12922 // display results
12923
12924 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12925 {
12926 if (device_param->skipped == 0)
12927 {
12928 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12929 device_id + 1,
12930 device_name,
12931 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
12932 (unsigned int) (device_global_mem / 1024 / 1024),
12933 (unsigned int) (device_maxclock_frequency),
12934 (unsigned int) device_processors);
12935 }
12936 else
12937 {
12938 log_info ("Device #%u: %s, skipped",
12939 device_id + 1,
12940 device_name);
12941 }
12942 }
12943
12944 // common driver check
12945
12946 if (device_param->skipped == 0)
12947 {
12948 if (strstr (device_version, "pocl"))
12949 {
12950 if (force == 0)
12951 {
12952 log_info ("");
12953 log_info ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
12954 log_info ("You are STRONGLY encouraged not to use it");
12955 log_info ("You can use --force to override this but do not post error reports if you do so");
12956 log_info ("");
12957
12958 return (-1);
12959 }
12960 }
12961
12962 if (device_type & CL_DEVICE_TYPE_GPU)
12963 {
12964 if (vendor_id == VENDOR_ID_NV)
12965 {
12966 if (device_param->kernel_exec_timeout != 0)
12967 {
12968 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);
12969 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12970 }
12971 }
12972 else if (vendor_id == VENDOR_ID_AMD)
12973 {
12974 int catalyst_check = (force == 1) ? 0 : 1;
12975
12976 int catalyst_warn = 0;
12977
12978 int catalyst_broken = 0;
12979
12980 if (catalyst_check == 1)
12981 {
12982 catalyst_warn = 1;
12983
12984 // v14.9 and higher
12985 if (atoi (device_param->driver_version) >= 1573)
12986 {
12987 catalyst_warn = 0;
12988 }
12989
12990 catalyst_check = 0;
12991 }
12992
12993 if (catalyst_broken == 1)
12994 {
12995 log_info ("");
12996 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
12997 log_info ("It will pass over cracked hashes and does not report them as cracked");
12998 log_info ("You are STRONGLY encouraged not to use it");
12999 log_info ("You can use --force to override this but do not post error reports if you do so");
13000 log_info ("");
13001
13002 return (-1);
13003 }
13004
13005 if (catalyst_warn == 1)
13006 {
13007 log_info ("");
13008 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13009 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13010 log_info ("See oclHashcat's homepage for official supported catalyst drivers");
13011 #ifdef _WIN
13012 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13013 #endif
13014 log_info ("You can use --force to override this but do not post error reports if you do so");
13015 log_info ("");
13016
13017 return (-1);
13018 }
13019 }
13020 }
13021
13022 /**
13023 * kernel accel and loops tuning db adjustment
13024 */
13025
13026 device_param->kernel_accel_min = 1;
13027 device_param->kernel_accel_max = 1024;
13028
13029 device_param->kernel_loops_min = 1;
13030 device_param->kernel_loops_max = 1024;
13031
13032 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13033
13034 if (tuningdb_entry)
13035 {
13036 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13037 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13038
13039 if (_kernel_accel)
13040 {
13041 device_param->kernel_accel_min = _kernel_accel;
13042 device_param->kernel_accel_max = _kernel_accel;
13043 }
13044
13045 if (_kernel_loops)
13046 {
13047 if (workload_profile == 1)
13048 {
13049 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13050 }
13051 else if (workload_profile == 2)
13052 {
13053 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13054 }
13055
13056 device_param->kernel_loops_min = _kernel_loops;
13057 device_param->kernel_loops_max = _kernel_loops;
13058 }
13059 }
13060
13061 // commandline parameters overwrite tuningdb entries
13062
13063 if (kernel_accel)
13064 {
13065 device_param->kernel_accel_min = kernel_accel;
13066 device_param->kernel_accel_max = kernel_accel;
13067 }
13068
13069 if (kernel_loops)
13070 {
13071 device_param->kernel_loops_min = kernel_loops;
13072 device_param->kernel_loops_max = kernel_loops;
13073 }
13074
13075 /**
13076 * activate device
13077 */
13078
13079 devices_active++;
13080 }
13081
13082 // next please
13083
13084 devices_cnt++;
13085 }
13086 }
13087
13088 if (keyspace == 0 && devices_active == 0)
13089 {
13090 log_error ("ERROR: No devices found/left");
13091
13092 return (-1);
13093 }
13094
13095 // 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)
13096
13097 if (devices_filter != (uint) -1)
13098 {
13099 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
13100
13101 if (devices_filter > devices_cnt_mask)
13102 {
13103 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
13104
13105 return (-1);
13106 }
13107 }
13108
13109 data.devices_cnt = devices_cnt;
13110
13111 data.devices_active = devices_active;
13112
13113 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13114 {
13115 log_info ("");
13116 }
13117
13118 /**
13119 * HM devices: init
13120 */
13121
13122 #ifdef HAVE_HWMON
13123 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13124 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13125 #endif
13126
13127 #ifdef HAVE_ADL
13128 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13129 #endif
13130
13131 if (gpu_temp_disable == 0)
13132 {
13133 #if defined(WIN) && defined(HAVE_NVAPI)
13134 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13135
13136 if (nvapi_init (nvapi) == 0)
13137 data.hm_nv = nvapi;
13138
13139 if (data.hm_nv)
13140 {
13141 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13142 {
13143 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13144
13145 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13146
13147 int tmp_out = 0;
13148
13149 for (int i = 0; i < tmp_in; i++)
13150 {
13151 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13152 }
13153
13154 for (int i = 0; i < tmp_out; i++)
13155 {
13156 NV_GPU_COOLER_SETTINGS pCoolerSettings;
13157
13158 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
13159
13160 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;
13161 }
13162 }
13163 }
13164 #endif // WIN && HAVE_NVAPI
13165
13166 #if defined(LINUX) && defined(HAVE_NVML)
13167 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13168
13169 if (nvml_init (nvml) == 0)
13170 data.hm_nv = nvml;
13171
13172 if (data.hm_nv)
13173 {
13174 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13175 {
13176 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13177
13178 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13179
13180 int tmp_out = 0;
13181
13182 for (int i = 0; i < tmp_in; i++)
13183 {
13184 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13185 }
13186
13187 for (int i = 0; i < tmp_out; i++)
13188 {
13189 unsigned int speed;
13190
13191 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;
13192 }
13193 }
13194 }
13195 #endif // LINUX && HAVE_NVML
13196
13197 data.hm_amd = NULL;
13198
13199 #ifdef HAVE_ADL
13200 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13201
13202 if (adl_init (adl) == 0)
13203 data.hm_amd = adl;
13204
13205 if (data.hm_amd)
13206 {
13207 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13208 {
13209 // total number of adapters
13210
13211 int hm_adapters_num;
13212
13213 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13214
13215 // adapter info
13216
13217 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13218
13219 if (lpAdapterInfo == NULL) return (-1);
13220
13221 // get a list (of ids of) valid/usable adapters
13222
13223 int num_adl_adapters = 0;
13224
13225 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13226
13227 if (num_adl_adapters > 0)
13228 {
13229 hc_thread_mutex_lock (mux_adl);
13230
13231 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13232
13233 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13234
13235 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13236 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13237
13238 hc_thread_mutex_unlock (mux_adl);
13239 }
13240
13241 myfree (valid_adl_device_list);
13242 myfree (lpAdapterInfo);
13243 }
13244 }
13245 #endif // HAVE_ADL
13246
13247 if (data.hm_amd == NULL && data.hm_nv == NULL)
13248 {
13249 gpu_temp_disable = 1;
13250 }
13251 }
13252
13253 /**
13254 * OpenCL devices: allocate buffer for device specific information
13255 */
13256
13257 #ifdef HAVE_HWMON
13258 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13259
13260 #ifdef HAVE_ADL
13261 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13262
13263 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13264 #endif // ADL
13265 #endif
13266
13267 /**
13268 * enable custom signal handler(s)
13269 */
13270
13271 if (benchmark == 0)
13272 {
13273 hc_signal (sigHandler_default);
13274 }
13275 else
13276 {
13277 hc_signal (sigHandler_benchmark);
13278 }
13279
13280 /**
13281 * User-defined GPU temp handling
13282 */
13283
13284 #ifdef HAVE_HWMON
13285 if (gpu_temp_disable == 1)
13286 {
13287 gpu_temp_abort = 0;
13288 gpu_temp_retain = 0;
13289 }
13290
13291 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13292 {
13293 if (gpu_temp_abort < gpu_temp_retain)
13294 {
13295 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13296
13297 return (-1);
13298 }
13299 }
13300
13301 data.gpu_temp_disable = gpu_temp_disable;
13302 data.gpu_temp_abort = gpu_temp_abort;
13303 data.gpu_temp_retain = gpu_temp_retain;
13304 #endif
13305
13306 /**
13307 * inform the user
13308 */
13309
13310 if (data.quiet == 0)
13311 {
13312 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13313
13314 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);
13315
13316 if (attack_mode == ATTACK_MODE_STRAIGHT)
13317 {
13318 log_info ("Rules: %u", kernel_rules_cnt);
13319 }
13320
13321 if (opti_type)
13322 {
13323 log_info ("Applicable Optimizers:");
13324
13325 for (uint i = 0; i < 32; i++)
13326 {
13327 const uint opti_bit = 1u << i;
13328
13329 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13330 }
13331 }
13332
13333 /**
13334 * Watchdog and Temperature balance
13335 */
13336
13337 #ifdef HAVE_HWMON
13338 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13339 {
13340 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13341 }
13342
13343 if (gpu_temp_abort == 0)
13344 {
13345 log_info ("Watchdog: Temperature abort trigger disabled");
13346 }
13347 else
13348 {
13349 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13350 }
13351
13352 if (gpu_temp_retain == 0)
13353 {
13354 log_info ("Watchdog: Temperature retain trigger disabled");
13355 }
13356 else
13357 {
13358 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13359 }
13360 #endif
13361 }
13362
13363 if (data.quiet == 0) log_info ("");
13364
13365 /**
13366 * HM devices: copy
13367 */
13368
13369 if (gpu_temp_disable == 0)
13370 {
13371 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13372 {
13373 hc_device_param_t *device_param = &data.devices_param[device_id];
13374
13375 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13376
13377 if (device_param->skipped) continue;
13378
13379 const uint platform_devices_id = device_param->platform_devices_id;
13380
13381 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13382 if (device_param->vendor_id == VENDOR_ID_NV)
13383 {
13384 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13385 }
13386 #endif
13387
13388 #ifdef HAVE_ADL
13389 if (device_param->vendor_id == VENDOR_ID_AMD)
13390 {
13391 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13392 }
13393 #endif
13394 }
13395 }
13396
13397 /*
13398 * Temporary fix:
13399 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13400 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13401 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13402 * Driver / ADL bug?
13403 */
13404
13405 #ifdef HAVE_ADL
13406 if (powertune_enable == 1)
13407 {
13408 hc_thread_mutex_lock (mux_adl);
13409
13410 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13411 {
13412 hc_device_param_t *device_param = &data.devices_param[device_id];
13413
13414 if (device_param->skipped) continue;
13415
13416 if (data.hm_device[device_id].od_version == 6)
13417 {
13418 // set powertune value only
13419
13420 int powertune_supported = 0;
13421
13422 int ADL_rc = 0;
13423
13424 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13425 {
13426 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13427
13428 return (-1);
13429 }
13430
13431 if (powertune_supported != 0)
13432 {
13433 // powertune set
13434 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13435
13436 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13437 {
13438 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13439
13440 return (-1);
13441 }
13442
13443 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13444 {
13445 log_error ("ERROR: Failed to set new ADL PowerControl values");
13446
13447 return (-1);
13448 }
13449 }
13450 }
13451 }
13452
13453 hc_thread_mutex_unlock (mux_adl);
13454 }
13455 #endif // HAVE_ADK
13456 #endif // HAVE_HWMON
13457
13458 #ifdef DEBUG
13459 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
13460 #endif
13461
13462 uint kernel_power_all = 0;
13463
13464 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13465 {
13466 /**
13467 * host buffer
13468 */
13469
13470 hc_device_param_t *device_param = &data.devices_param[device_id];
13471
13472 if (device_param->skipped) continue;
13473
13474 /**
13475 * device properties
13476 */
13477
13478 const char *device_name_chksum = device_param->device_name_chksum;
13479 const u32 device_processors = device_param->device_processors;
13480 const u32 device_processor_cores = device_param->device_processor_cores;
13481
13482 /**
13483 * create context for each device
13484 */
13485
13486 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
13487
13488 /**
13489 * create command-queue
13490 */
13491
13492 // not supported with NV
13493 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13494
13495 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
13496
13497 /**
13498 * create input buffers on device : calculate size of fixed memory buffers
13499 */
13500
13501 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13502 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13503
13504 device_param->size_root_css = size_root_css;
13505 device_param->size_markov_css = size_markov_css;
13506
13507 uint size_results = KERNEL_THREADS * sizeof (uint);
13508
13509 device_param->size_results = size_results;
13510
13511 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13512 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13513
13514 uint size_plains = digests_cnt * sizeof (plain_t);
13515 uint size_salts = salts_cnt * sizeof (salt_t);
13516 uint size_esalts = salts_cnt * esalt_size;
13517
13518 device_param->size_plains = size_plains;
13519 device_param->size_digests = size_digests;
13520 device_param->size_shown = size_shown;
13521 device_param->size_salts = size_salts;
13522
13523 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13524 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13525 uint size_tm = 32 * sizeof (bs_word_t);
13526
13527 // scryptV stuff
13528
13529 u64 size_scryptV = 1;
13530
13531 if ((hash_mode == 8900) || (hash_mode == 9300))
13532 {
13533 uint tmto_start = 0;
13534 uint tmto_stop = 10;
13535
13536 if (scrypt_tmto)
13537 {
13538 tmto_start = scrypt_tmto;
13539 }
13540 else
13541 {
13542 // in case the user did not specify the tmto manually
13543 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13544 // but set the lower end only in case the user has a device with too less memory
13545
13546 if (hash_mode == 8900)
13547 {
13548 if (device_param->vendor_id == VENDOR_ID_AMD)
13549 {
13550 tmto_start = 1;
13551 }
13552 else if (device_param->vendor_id == VENDOR_ID_NV)
13553 {
13554 tmto_start = 3;
13555 }
13556 }
13557 else if (hash_mode == 9300)
13558 {
13559 if (device_param->vendor_id == VENDOR_ID_AMD)
13560 {
13561 tmto_start = 3;
13562 }
13563 else if (device_param->vendor_id == VENDOR_ID_NV)
13564 {
13565 tmto_start = 5;
13566 }
13567 }
13568 }
13569
13570 if (quiet == 0) log_info ("");
13571
13572 uint shader_per_mp = 1;
13573
13574 if (device_param->vendor_id == VENDOR_ID_AMD)
13575 {
13576 shader_per_mp = 8;
13577 }
13578 else if (device_param->vendor_id == VENDOR_ID_NV)
13579 {
13580 shader_per_mp = 32;
13581 }
13582
13583 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13584 {
13585 // TODO: in theory the following calculation needs to be done per salt, not global
13586 // we assume all hashes have the same scrypt settings
13587
13588 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13589
13590 size_scryptV /= 1 << tmto;
13591
13592 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13593
13594 if (size_scryptV > device_param->device_maxmem_alloc)
13595 {
13596 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13597
13598 continue;
13599 }
13600
13601 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13602 {
13603 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13604 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13605 }
13606
13607 break;
13608 }
13609
13610 if (data.salts_buf[0].scrypt_phy == 0)
13611 {
13612 log_error ("ERROR: can't allocate enough device memory");
13613
13614 return -1;
13615 }
13616
13617 if (quiet == 0) log_info ("");
13618 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13619 }
13620
13621 /**
13622 * create input buffers on device : calculate size of dynamic size memory buffers
13623 */
13624
13625 uint kernel_threads = KERNEL_THREADS;
13626
13627 // some algorithms need a fixed kernel-threads count (mostly because of shared memory usage)
13628
13629 if (hash_mode == 3200) kernel_threads = 8;
13630 if (hash_mode == 9000) kernel_threads = 8;
13631
13632 /**
13633 * some algorithms need a fixed kernel-loops count
13634 */
13635
13636 if (hash_mode == 1500)
13637 {
13638 const u32 kernel_loops_fixed = 1024;
13639
13640 device_param->kernel_loops_min = kernel_loops_fixed;
13641 device_param->kernel_loops_max = kernel_loops_fixed;
13642 }
13643
13644 if (hash_mode == 3000)
13645 {
13646 const u32 kernel_loops_fixed = 1024;
13647
13648 device_param->kernel_loops_min = kernel_loops_fixed;
13649 device_param->kernel_loops_max = kernel_loops_fixed;
13650 }
13651
13652 if (hash_mode == 8900)
13653 {
13654 const u32 kernel_loops_fixed = 1;
13655
13656 device_param->kernel_loops_min = kernel_loops_fixed;
13657 device_param->kernel_loops_max = kernel_loops_fixed;
13658 }
13659
13660 if (hash_mode == 9300)
13661 {
13662 const u32 kernel_loops_fixed = 1;
13663
13664 device_param->kernel_loops_min = kernel_loops_fixed;
13665 device_param->kernel_loops_max = kernel_loops_fixed;
13666 }
13667
13668 if (hash_mode == 12500)
13669 {
13670 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
13671
13672 device_param->kernel_loops_min = kernel_loops_fixed;
13673 device_param->kernel_loops_max = kernel_loops_fixed;
13674 }
13675
13676 /**
13677 * some algorithms have a maximum kernel-loops count
13678 */
13679
13680 if (attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
13681 {
13682 if (data.salts_buf[0].salt_iter < device_param->kernel_loops_max)
13683 {
13684 device_param->kernel_loops_max = data.salts_buf[0].salt_iter;
13685 }
13686 }
13687
13688 /**
13689 * some algorithms need a special kernel-accel
13690 */
13691
13692 if (hash_mode == 8900)
13693 {
13694 device_param->kernel_accel_min = 1;
13695 device_param->kernel_accel_max = 64;
13696 }
13697
13698 if (hash_mode == 9300)
13699 {
13700 device_param->kernel_accel_min = 1;
13701 device_param->kernel_accel_max = 64;
13702 }
13703
13704 u32 kernel_accel_min = device_param->kernel_accel_min;
13705 u32 kernel_accel_max = device_param->kernel_accel_max;
13706
13707 // find out if we would request too much memory on memory blocks which are based on kernel_accel
13708
13709 uint size_pws = 4;
13710 uint size_tmps = 4;
13711 uint size_hooks = 4;
13712
13713 while (kernel_accel_max >= kernel_accel_min)
13714 {
13715 uint kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
13716
13717 // size_pws
13718
13719 size_pws = kernel_power_max * sizeof (pw_t);
13720
13721 // size_tmps
13722
13723 switch (hash_mode)
13724 {
13725 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
13726 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13727 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13728 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13729 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
13730 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
13731 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
13732 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
13733 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
13734 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
13735 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13736 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13737 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13738 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13739 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13740 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13741 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13742 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13743 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13744 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13745 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13746 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13747 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13748 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
13749 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
13750 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
13751 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
13752 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
13753 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13754 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13755 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
13756 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
13757 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13758 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
13759 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13760 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
13761 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
13762 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13763 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13764 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
13765 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
13766 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
13767 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13768 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
13769 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
13770 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
13771 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
13772 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13773 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
13774 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
13775 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
13776 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
13777 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13778 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
13779 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
13780 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
13781 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
13782 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
13783 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13784 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13785 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13786 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
13787 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
13788 };
13789
13790 // size_hooks
13791
13792 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13793 {
13794 // none yet
13795 }
13796
13797 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
13798 // if not, decrease amplifier and try again
13799
13800 int skip = 0;
13801
13802 if (size_pws > device_param->device_maxmem_alloc) skip = 1;
13803 if (size_tmps > device_param->device_maxmem_alloc) skip = 1;
13804 if (size_hooks > device_param->device_maxmem_alloc) skip = 1;
13805
13806 if (( bitmap_size
13807 + bitmap_size
13808 + bitmap_size
13809 + bitmap_size
13810 + bitmap_size
13811 + bitmap_size
13812 + bitmap_size
13813 + bitmap_size
13814 + size_bfs
13815 + size_combs
13816 + size_digests
13817 + size_esalts
13818 + size_hooks
13819 + size_markov_css
13820 + size_plains
13821 + size_pws
13822 + size_results
13823 + size_root_css
13824 + size_rules
13825 + size_rules_c
13826 + size_salts
13827 + size_scryptV
13828 + size_shown
13829 + size_tm
13830 + size_tmps) > device_param->device_global_mem) skip = 1;
13831
13832 if (skip == 1)
13833 {
13834 kernel_accel_max--;
13835
13836 continue;
13837 }
13838
13839 break;
13840 }
13841
13842 /*
13843 if (kernel_accel_max == 0)
13844 {
13845 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
13846
13847 return -1;
13848 }
13849 */
13850
13851 device_param->kernel_accel_min = kernel_accel_min;
13852 device_param->kernel_accel_max = kernel_accel_max;
13853
13854 /*
13855 if (kernel_accel_max < kernel_accel)
13856 {
13857 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
13858
13859 device_param->kernel_accel = kernel_accel_max;
13860 }
13861 */
13862
13863 device_param->size_bfs = size_bfs;
13864 device_param->size_combs = size_combs;
13865 device_param->size_rules = size_rules;
13866 device_param->size_rules_c = size_rules_c;
13867 device_param->size_pws = size_pws;
13868 device_param->size_tmps = size_tmps;
13869 device_param->size_hooks = size_hooks;
13870
13871 // do not confuse kernel_accel_max with kernel_accel here
13872
13873 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
13874
13875 device_param->kernel_threads = kernel_threads;
13876 device_param->kernel_power_user = kernel_power;
13877
13878 kernel_power_all += kernel_power;
13879
13880 /**
13881 * default building options
13882 */
13883
13884 char build_opts[1024] = { 0 };
13885
13886 // we don't have sm_* on vendors not NV but it doesn't matter
13887
13888 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);
13889
13890 /**
13891 * main kernel
13892 */
13893
13894 {
13895 /**
13896 * kernel source filename
13897 */
13898
13899 char source_file[256] = { 0 };
13900
13901 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13902
13903 struct stat sst;
13904
13905 if (stat (source_file, &sst) == -1)
13906 {
13907 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13908
13909 return -1;
13910 }
13911
13912 /**
13913 * kernel cached filename
13914 */
13915
13916 char cached_file[256] = { 0 };
13917
13918 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
13919
13920 int cached = 1;
13921
13922 struct stat cst;
13923
13924 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
13925 {
13926 cached = 0;
13927 }
13928
13929 /**
13930 * kernel compile or load
13931 */
13932
13933 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13934
13935 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13936
13937 if (force_jit_compilation == -1)
13938 {
13939 if (cached == 0)
13940 {
13941 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13942
13943 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13944
13945 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13946
13947 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
13948
13949 #ifdef DEBUG
13950 size_t build_log_size = 0;
13951
13952 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
13953
13954 if (build_log_size > 1)
13955 {
13956 char *build_log = (char *) malloc (build_log_size + 1);
13957
13958 memset (build_log, 0, build_log_size + 1);
13959
13960 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
13961
13962 puts (build_log);
13963
13964 free (build_log);
13965 }
13966 #endif
13967
13968 if (rc != 0)
13969 {
13970 device_param->skipped = true;
13971 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13972 continue;
13973 }
13974
13975 size_t binary_size;
13976
13977 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13978
13979 u8 *binary = (u8 *) mymalloc (binary_size);
13980
13981 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13982
13983 writeProgramBin (cached_file, binary, binary_size);
13984
13985 local_free (binary);
13986 }
13987 else
13988 {
13989 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13990
13991 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13992
13993 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13994
13995 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
13996 }
13997 }
13998 else
13999 {
14000 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
14001
14002 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14003
14004 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14005
14006 char build_opts_update[1024] = { 0 };
14007
14008 if (force_jit_compilation == 1500)
14009 {
14010 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
14011 }
14012 else if (force_jit_compilation == 8900)
14013 {
14014 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);
14015 }
14016 else
14017 {
14018 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
14019 }
14020
14021 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
14022
14023 #ifdef DEBUG
14024 size_t build_log_size = 0;
14025
14026 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14027
14028 if (build_log_size > 1)
14029 {
14030 char *build_log = (char *) malloc (build_log_size + 1);
14031
14032 memset (build_log, 0, build_log_size + 1);
14033
14034 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14035
14036 puts (build_log);
14037
14038 free (build_log);
14039 }
14040 #endif
14041
14042 if (rc != 0)
14043 {
14044 device_param->skipped = true;
14045
14046 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14047 }
14048 }
14049
14050 local_free (kernel_lengths);
14051 local_free (kernel_sources[0]);
14052 local_free (kernel_sources);
14053 }
14054
14055 /**
14056 * word generator kernel
14057 */
14058
14059 if (attack_mode != ATTACK_MODE_STRAIGHT)
14060 {
14061 /**
14062 * kernel mp source filename
14063 */
14064
14065 char source_file[256] = { 0 };
14066
14067 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
14068
14069 struct stat sst;
14070
14071 if (stat (source_file, &sst) == -1)
14072 {
14073 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14074
14075 return -1;
14076 }
14077
14078 /**
14079 * kernel mp cached filename
14080 */
14081
14082 char cached_file[256] = { 0 };
14083
14084 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
14085
14086 int cached = 1;
14087
14088 struct stat cst;
14089
14090 if (stat (cached_file, &cst) == -1)
14091 {
14092 cached = 0;
14093 }
14094
14095 /**
14096 * kernel compile or load
14097 */
14098
14099 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14100
14101 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14102
14103 if (cached == 0)
14104 {
14105 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14106
14107 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14108
14109 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14110
14111 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
14112
14113 if (rc != 0)
14114 {
14115 device_param->skipped = true;
14116 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14117 continue;
14118 }
14119
14120 size_t binary_size;
14121
14122 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14123
14124 u8 *binary = (u8 *) mymalloc (binary_size);
14125
14126 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14127
14128 writeProgramBin (cached_file, binary, binary_size);
14129
14130 local_free (binary);
14131 }
14132 else
14133 {
14134 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14135
14136 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14137
14138 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14139
14140 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
14141 }
14142
14143 local_free (kernel_lengths);
14144 local_free (kernel_sources[0]);
14145 local_free (kernel_sources);
14146 }
14147
14148 /**
14149 * amplifier kernel
14150 */
14151
14152 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14153 {
14154
14155 }
14156 else
14157 {
14158 /**
14159 * kernel amp source filename
14160 */
14161
14162 char source_file[256] = { 0 };
14163
14164 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
14165
14166 struct stat sst;
14167
14168 if (stat (source_file, &sst) == -1)
14169 {
14170 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14171
14172 return -1;
14173 }
14174
14175 /**
14176 * kernel amp cached filename
14177 */
14178
14179 char cached_file[256] = { 0 };
14180
14181 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
14182
14183 int cached = 1;
14184
14185 struct stat cst;
14186
14187 if (stat (cached_file, &cst) == -1)
14188 {
14189 cached = 0;
14190 }
14191
14192 /**
14193 * kernel compile or load
14194 */
14195
14196 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14197
14198 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14199
14200 if (cached == 0)
14201 {
14202 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14203
14204 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14205
14206 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14207
14208 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
14209
14210 if (rc != 0)
14211 {
14212 device_param->skipped = true;
14213 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14214 continue;
14215 }
14216
14217 size_t binary_size;
14218
14219 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14220
14221 u8 *binary = (u8 *) mymalloc (binary_size);
14222
14223 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14224
14225 writeProgramBin (cached_file, binary, binary_size);
14226
14227 local_free (binary);
14228 }
14229 else
14230 {
14231 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14232
14233 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14234
14235 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14236
14237 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
14238 }
14239
14240 local_free (kernel_lengths);
14241 local_free (kernel_sources[0]);
14242 local_free (kernel_sources);
14243 }
14244
14245 // some algorithm collide too fast, make that impossible
14246
14247 if (benchmark == 1)
14248 {
14249 ((uint *) digests_buf)[0] = -1;
14250 ((uint *) digests_buf)[1] = -1;
14251 ((uint *) digests_buf)[2] = -1;
14252 ((uint *) digests_buf)[3] = -1;
14253 }
14254
14255 /**
14256 * global buffers
14257 */
14258
14259 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14260 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14261 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
14262 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
14263 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14264 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14265 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14266 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14267 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14268 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14269 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14270 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14271 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
14272 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
14273 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
14274 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
14275 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
14276 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
14277
14278 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);
14279 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);
14280 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);
14281 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);
14282 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);
14283 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);
14284 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);
14285 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);
14286 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
14287 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
14288 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
14289
14290 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
14291 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
14292 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
14293 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
14294 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
14295 run_kernel_bzero (device_param, device_param->d_result, size_results);
14296
14297 /**
14298 * special buffers
14299 */
14300
14301 if (attack_kern == ATTACK_KERN_STRAIGHT)
14302 {
14303 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
14304 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
14305
14306 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
14307
14308 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
14309 }
14310 else if (attack_kern == ATTACK_KERN_COMBI)
14311 {
14312 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14313 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14314 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14315 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14316
14317 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
14318 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
14319 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14320 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14321 }
14322 else if (attack_kern == ATTACK_KERN_BF)
14323 {
14324 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14325 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14326 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
14327 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14328 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14329
14330 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
14331 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
14332 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
14333 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14334 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14335 }
14336
14337 if (size_esalts)
14338 {
14339 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
14340
14341 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
14342 }
14343
14344 /**
14345 * main host data
14346 */
14347
14348 uint *result = (uint *) mymalloc (size_results);
14349
14350 device_param->result = result;
14351
14352 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
14353
14354 device_param->pws_buf = pws_buf;
14355
14356 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
14357
14358 device_param->combs_buf = combs_buf;
14359
14360 void *hooks_buf = mymalloc (size_hooks);
14361
14362 device_param->hooks_buf = hooks_buf;
14363
14364 /**
14365 * kernel args
14366 */
14367
14368 device_param->kernel_params_buf32[21] = bitmap_mask;
14369 device_param->kernel_params_buf32[22] = bitmap_shift1;
14370 device_param->kernel_params_buf32[23] = bitmap_shift2;
14371 device_param->kernel_params_buf32[24] = 0; // salt_pos
14372 device_param->kernel_params_buf32[25] = 0; // loop_pos
14373 device_param->kernel_params_buf32[26] = 0; // loop_cnt
14374 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
14375 device_param->kernel_params_buf32[28] = 0; // digests_cnt
14376 device_param->kernel_params_buf32[29] = 0; // digests_offset
14377 device_param->kernel_params_buf32[30] = 0; // combs_mode
14378 device_param->kernel_params_buf32[31] = 0; // gid_max
14379
14380 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14381 ? &device_param->d_pws_buf
14382 : &device_param->d_pws_amp_buf;
14383 device_param->kernel_params[ 1] = &device_param->d_rules_c;
14384 device_param->kernel_params[ 2] = &device_param->d_combs_c;
14385 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
14386 device_param->kernel_params[ 4] = &device_param->d_tmps;
14387 device_param->kernel_params[ 5] = &device_param->d_hooks;
14388 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
14389 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
14390 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
14391 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
14392 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
14393 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
14394 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
14395 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
14396 device_param->kernel_params[14] = &device_param->d_plain_bufs;
14397 device_param->kernel_params[15] = &device_param->d_digests_buf;
14398 device_param->kernel_params[16] = &device_param->d_digests_shown;
14399 device_param->kernel_params[17] = &device_param->d_salt_bufs;
14400 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
14401 device_param->kernel_params[19] = &device_param->d_result;
14402 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
14403 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
14404 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
14405 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
14406 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
14407 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
14408 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
14409 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
14410 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
14411 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
14412 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
14413 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
14414
14415 device_param->kernel_params_mp_buf64[3] = 0;
14416 device_param->kernel_params_mp_buf32[4] = 0;
14417 device_param->kernel_params_mp_buf32[5] = 0;
14418 device_param->kernel_params_mp_buf32[6] = 0;
14419 device_param->kernel_params_mp_buf32[7] = 0;
14420 device_param->kernel_params_mp_buf32[8] = 0;
14421
14422 device_param->kernel_params_mp[0] = NULL;
14423 device_param->kernel_params_mp[1] = NULL;
14424 device_param->kernel_params_mp[2] = NULL;
14425 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
14426 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
14427 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
14428 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
14429 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
14430 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
14431
14432 device_param->kernel_params_mp_l_buf64[3] = 0;
14433 device_param->kernel_params_mp_l_buf32[4] = 0;
14434 device_param->kernel_params_mp_l_buf32[5] = 0;
14435 device_param->kernel_params_mp_l_buf32[6] = 0;
14436 device_param->kernel_params_mp_l_buf32[7] = 0;
14437 device_param->kernel_params_mp_l_buf32[8] = 0;
14438 device_param->kernel_params_mp_l_buf32[9] = 0;
14439
14440 device_param->kernel_params_mp_l[0] = NULL;
14441 device_param->kernel_params_mp_l[1] = NULL;
14442 device_param->kernel_params_mp_l[2] = NULL;
14443 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14444 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14445 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14446 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14447 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14448 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14449 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14450
14451 device_param->kernel_params_mp_r_buf64[3] = 0;
14452 device_param->kernel_params_mp_r_buf32[4] = 0;
14453 device_param->kernel_params_mp_r_buf32[5] = 0;
14454 device_param->kernel_params_mp_r_buf32[6] = 0;
14455 device_param->kernel_params_mp_r_buf32[7] = 0;
14456 device_param->kernel_params_mp_r_buf32[8] = 0;
14457
14458 device_param->kernel_params_mp_r[0] = NULL;
14459 device_param->kernel_params_mp_r[1] = NULL;
14460 device_param->kernel_params_mp_r[2] = NULL;
14461 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14462 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14463 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14464 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14465 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14466 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14467
14468 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14469 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14470
14471 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14472 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14473 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14474 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14475 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14476 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14477 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14478
14479 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14480 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14481
14482 /**
14483 * kernel name
14484 */
14485
14486 char kernel_name[64] = { 0 };
14487
14488 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14489 {
14490 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14491 {
14492 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14493
14494 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14495
14496 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14497
14498 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14499
14500 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14501
14502 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14503 }
14504 else
14505 {
14506 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14507
14508 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14509
14510 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14511
14512 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14513
14514 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14515
14516 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14517 }
14518
14519 if (data.attack_mode == ATTACK_MODE_BF)
14520 {
14521 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14522 {
14523 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14524
14525 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14526 }
14527 }
14528 }
14529 else
14530 {
14531 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14532
14533 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14534
14535 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14536
14537 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14538
14539 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14540
14541 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14542
14543 if (opts_type & OPTS_TYPE_HOOK12)
14544 {
14545 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14546
14547 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14548 }
14549
14550 if (opts_type & OPTS_TYPE_HOOK23)
14551 {
14552 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14553
14554 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14555 }
14556 }
14557
14558 for (uint i = 0; i <= 20; i++)
14559 {
14560 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14561 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14562 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14563
14564 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14565 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14566 }
14567
14568 for (uint i = 21; i <= 31; i++)
14569 {
14570 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14571 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14572 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14573
14574 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14575 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14576 }
14577
14578 if (attack_mode == ATTACK_MODE_BF)
14579 {
14580 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
14581 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
14582
14583 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14584 {
14585 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14586 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14587 }
14588 }
14589 else if (attack_mode == ATTACK_MODE_HYBRID1)
14590 {
14591 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14592 }
14593 else if (attack_mode == ATTACK_MODE_HYBRID2)
14594 {
14595 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14596 }
14597
14598 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14599 {
14600 // nothing to do
14601 }
14602 else
14603 {
14604 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
14605 }
14606
14607 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14608 {
14609 // nothing to do
14610 }
14611 else
14612 {
14613 for (uint i = 0; i < 5; i++)
14614 {
14615 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14616 }
14617
14618 for (uint i = 5; i < 7; i++)
14619 {
14620 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14621 }
14622 }
14623
14624 /**
14625 * Store initial fanspeed if gpu_temp_retain is enabled
14626 */
14627
14628 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
14629 int gpu_temp_retain_set = 0;
14630
14631 if (gpu_temp_disable == 0)
14632 {
14633 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14634 {
14635 hc_thread_mutex_lock (mux_adl);
14636
14637 if (data.hm_device[device_id].fan_supported == 1)
14638 {
14639 if (gpu_temp_retain_chgd == 0)
14640 {
14641 uint cur_temp = 0;
14642 uint default_temp = 0;
14643
14644 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);
14645
14646 if (ADL_rc == ADL_OK)
14647 {
14648 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14649
14650 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14651
14652 // special case with multi gpu setups: always use minimum retain
14653
14654 if (gpu_temp_retain_set == 0)
14655 {
14656 gpu_temp_retain = gpu_temp_retain_target;
14657 gpu_temp_retain_set = 1;
14658 }
14659 else
14660 {
14661 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14662 }
14663
14664 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14665 }
14666 }
14667
14668 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14669
14670 temp_retain_fanspeed_value[device_id] = fan_speed;
14671
14672 if (fan_speed == -1)
14673 {
14674 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14675
14676 temp_retain_fanspeed_value[device_id] = 0;
14677 }
14678 }
14679
14680 hc_thread_mutex_unlock (mux_adl);
14681 }
14682 }
14683
14684 /**
14685 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14686 */
14687
14688 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14689 {
14690 hc_thread_mutex_lock (mux_adl);
14691
14692 if (data.hm_device[device_id].od_version == 6)
14693 {
14694 int ADL_rc;
14695
14696 // check powertune capabilities first, if not available then skip device
14697
14698 int powertune_supported = 0;
14699
14700 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14701 {
14702 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14703
14704 return (-1);
14705 }
14706
14707 if (powertune_supported != 0)
14708 {
14709 // powercontrol settings
14710
14711 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14712
14713 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14714 {
14715 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14716 }
14717
14718 if (ADL_rc != ADL_OK)
14719 {
14720 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14721
14722 return (-1);
14723 }
14724
14725 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14726 {
14727 log_error ("ERROR: Failed to set new ADL PowerControl values");
14728
14729 return (-1);
14730 }
14731
14732 // clocks
14733
14734 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14735
14736 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14737
14738 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)
14739 {
14740 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14741
14742 return (-1);
14743 }
14744
14745 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14746
14747 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14748
14749 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14750 {
14751 log_error ("ERROR: Failed to get ADL device capabilities");
14752
14753 return (-1);
14754 }
14755
14756 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14757 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14758
14759 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14760 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14761
14762 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14763 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14764
14765 // warning if profile has too low max values
14766
14767 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14768 {
14769 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14770 }
14771
14772 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14773 {
14774 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14775 }
14776
14777 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14778
14779 performance_state->iNumberOfPerformanceLevels = 2;
14780
14781 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14782 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14783 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14784 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14785
14786 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)
14787 {
14788 log_info ("ERROR: Failed to set ADL performance state");
14789
14790 return (-1);
14791 }
14792
14793 local_free (performance_state);
14794 }
14795 }
14796
14797 hc_thread_mutex_unlock (mux_adl);
14798 }
14799 #endif // HAVE_HWMON && HAVE_ADL
14800 }
14801
14802 data.kernel_power_all = kernel_power_all;
14803
14804 if (data.quiet == 0) log_info ("");
14805
14806 /**
14807 * In benchmark-mode, inform user which algorithm is checked
14808 */
14809
14810 if (benchmark == 1)
14811 {
14812 quiet = 0;
14813
14814 data.quiet = quiet;
14815
14816 char *hash_type = strhashtype (data.hash_mode); // not a bug
14817
14818 log_info ("Hashtype: %s", hash_type);
14819 log_info ("");
14820 }
14821
14822 /**
14823 * keep track of the progress
14824 */
14825
14826 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14827 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14828 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14829
14830 /**
14831 * open filehandles
14832 */
14833
14834 #if _WIN
14835 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14836 {
14837 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14838
14839 return (-1);
14840 }
14841
14842 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14843 {
14844 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14845
14846 return (-1);
14847 }
14848
14849 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14850 {
14851 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14852
14853 return (-1);
14854 }
14855 #endif
14856
14857 /**
14858 * dictionary pad
14859 */
14860
14861 segment_size *= (1024 * 1024);
14862
14863 data.segment_size = segment_size;
14864
14865 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14866
14867 wl_data->buf = (char *) mymalloc (segment_size);
14868 wl_data->avail = segment_size;
14869 wl_data->incr = segment_size;
14870 wl_data->cnt = 0;
14871 wl_data->pos = 0;
14872
14873 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14874
14875 data.wordlist_mode = wordlist_mode;
14876
14877 cs_t *css_buf = NULL;
14878 uint css_cnt = 0;
14879 uint dictcnt = 0;
14880 uint maskcnt = 1;
14881 char **masks = NULL;
14882 char **dictfiles = NULL;
14883
14884 uint mask_from_file = 0;
14885
14886 if (attack_mode == ATTACK_MODE_STRAIGHT)
14887 {
14888 if (wordlist_mode == WL_MODE_FILE)
14889 {
14890 int wls_left = myargc - (optind + 1);
14891
14892 for (int i = 0; i < wls_left; i++)
14893 {
14894 char *l0_filename = myargv[optind + 1 + i];
14895
14896 struct stat l0_stat;
14897
14898 if (stat (l0_filename, &l0_stat) == -1)
14899 {
14900 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14901
14902 return (-1);
14903 }
14904
14905 uint is_dir = S_ISDIR (l0_stat.st_mode);
14906
14907 if (is_dir == 0)
14908 {
14909 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14910
14911 dictcnt++;
14912
14913 dictfiles[dictcnt - 1] = l0_filename;
14914 }
14915 else
14916 {
14917 // do not allow --keyspace w/ a directory
14918
14919 if (keyspace == 1)
14920 {
14921 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14922
14923 return (-1);
14924 }
14925
14926 char **dictionary_files = NULL;
14927
14928 dictionary_files = scan_directory (l0_filename);
14929
14930 if (dictionary_files != NULL)
14931 {
14932 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14933
14934 for (int d = 0; dictionary_files[d] != NULL; d++)
14935 {
14936 char *l1_filename = dictionary_files[d];
14937
14938 struct stat l1_stat;
14939
14940 if (stat (l1_filename, &l1_stat) == -1)
14941 {
14942 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14943
14944 return (-1);
14945 }
14946
14947 if (S_ISREG (l1_stat.st_mode))
14948 {
14949 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14950
14951 dictcnt++;
14952
14953 dictfiles[dictcnt - 1] = strdup (l1_filename);
14954 }
14955 }
14956 }
14957
14958 local_free (dictionary_files);
14959 }
14960 }
14961
14962 if (dictcnt < 1)
14963 {
14964 log_error ("ERROR: No usable dictionary file found.");
14965
14966 return (-1);
14967 }
14968 }
14969 else if (wordlist_mode == WL_MODE_STDIN)
14970 {
14971 dictcnt = 1;
14972 }
14973 }
14974 else if (attack_mode == ATTACK_MODE_COMBI)
14975 {
14976 // display
14977
14978 char *dictfile1 = myargv[optind + 1 + 0];
14979 char *dictfile2 = myargv[optind + 1 + 1];
14980
14981 // find the bigger dictionary and use as base
14982
14983 FILE *fp1 = NULL;
14984 FILE *fp2 = NULL;
14985
14986 struct stat tmp_stat;
14987
14988 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14989 {
14990 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14991
14992 return (-1);
14993 }
14994
14995 if (stat (dictfile1, &tmp_stat) == -1)
14996 {
14997 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14998
14999 fclose (fp1);
15000
15001 return (-1);
15002 }
15003
15004 if (S_ISDIR (tmp_stat.st_mode))
15005 {
15006 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
15007
15008 fclose (fp1);
15009
15010 return (-1);
15011 }
15012
15013 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
15014 {
15015 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15016
15017 fclose (fp1);
15018
15019 return (-1);
15020 }
15021
15022 if (stat (dictfile2, &tmp_stat) == -1)
15023 {
15024 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15025
15026 fclose (fp1);
15027 fclose (fp2);
15028
15029 return (-1);
15030 }
15031
15032 if (S_ISDIR (tmp_stat.st_mode))
15033 {
15034 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
15035
15036 fclose (fp1);
15037 fclose (fp2);
15038
15039 return (-1);
15040 }
15041
15042 data.combs_cnt = 1;
15043
15044 data.quiet = 1;
15045
15046 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
15047
15048 data.quiet = quiet;
15049
15050 if (words1_cnt == 0)
15051 {
15052 log_error ("ERROR: %s: empty file", dictfile1);
15053
15054 fclose (fp1);
15055 fclose (fp2);
15056
15057 return (-1);
15058 }
15059
15060 data.combs_cnt = 1;
15061
15062 data.quiet = 1;
15063
15064 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
15065
15066 data.quiet = quiet;
15067
15068 if (words2_cnt == 0)
15069 {
15070 log_error ("ERROR: %s: empty file", dictfile2);
15071
15072 fclose (fp1);
15073 fclose (fp2);
15074
15075 return (-1);
15076 }
15077
15078 fclose (fp1);
15079 fclose (fp2);
15080
15081 data.dictfile = dictfile1;
15082 data.dictfile2 = dictfile2;
15083
15084 if (words1_cnt >= words2_cnt)
15085 {
15086 data.combs_cnt = words2_cnt;
15087 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15088
15089 dictfiles = &data.dictfile;
15090
15091 dictcnt = 1;
15092 }
15093 else
15094 {
15095 data.combs_cnt = words1_cnt;
15096 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15097
15098 dictfiles = &data.dictfile2;
15099
15100 dictcnt = 1;
15101
15102 // we also have to switch wordlist related rules!
15103
15104 char *tmpc = data.rule_buf_l;
15105
15106 data.rule_buf_l = data.rule_buf_r;
15107 data.rule_buf_r = tmpc;
15108
15109 int tmpi = data.rule_len_l;
15110
15111 data.rule_len_l = data.rule_len_r;
15112 data.rule_len_r = tmpi;
15113 }
15114 }
15115 else if (attack_mode == ATTACK_MODE_BF)
15116 {
15117 char *mask = NULL;
15118
15119 maskcnt = 0;
15120
15121 if (benchmark == 0)
15122 {
15123 mask = myargv[optind + 1];
15124
15125 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
15126
15127 if ((optind + 2) <= myargc)
15128 {
15129 struct stat file_stat;
15130
15131 if (stat (mask, &file_stat) == -1)
15132 {
15133 maskcnt = 1;
15134
15135 masks[maskcnt - 1] = mystrdup (mask);
15136 }
15137 else
15138 {
15139 int wls_left = myargc - (optind + 1);
15140
15141 uint masks_avail = INCR_MASKS;
15142
15143 for (int i = 0; i < wls_left; i++)
15144 {
15145 if (i != 0)
15146 {
15147 mask = myargv[optind + 1 + i];
15148
15149 if (stat (mask, &file_stat) == -1)
15150 {
15151 log_error ("ERROR: %s: %s", mask, strerror (errno));
15152
15153 return (-1);
15154 }
15155 }
15156
15157 uint is_file = S_ISREG (file_stat.st_mode);
15158
15159 if (is_file == 1)
15160 {
15161 FILE *mask_fp;
15162
15163 if ((mask_fp = fopen (mask, "r")) == NULL)
15164 {
15165 log_error ("ERROR: %s: %s", mask, strerror (errno));
15166
15167 return (-1);
15168 }
15169
15170 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15171
15172 while (!feof (mask_fp))
15173 {
15174 memset (line_buf, 0, HCBUFSIZ);
15175
15176 int line_len = fgetl (mask_fp, line_buf);
15177
15178 if (line_len == 0) continue;
15179
15180 if (line_buf[0] == '#') continue;
15181
15182 if (masks_avail == maskcnt)
15183 {
15184 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15185
15186 masks_avail += INCR_MASKS;
15187 }
15188
15189 masks[maskcnt] = mystrdup (line_buf);
15190
15191 maskcnt++;
15192 }
15193
15194 myfree (line_buf);
15195
15196 fclose (mask_fp);
15197 }
15198 else
15199 {
15200 log_error ("ERROR: %s: unsupported file-type", mask);
15201
15202 return (-1);
15203 }
15204 }
15205
15206 mask_from_file = 1;
15207 }
15208 }
15209 else
15210 {
15211 custom_charset_1 = (char *) "?l?d?u";
15212 custom_charset_2 = (char *) "?l?d";
15213 custom_charset_3 = (char *) "?l?d*!$@_";
15214
15215 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15216 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15217 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15218
15219 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
15220
15221 wordlist_mode = WL_MODE_MASK;
15222
15223 data.wordlist_mode = wordlist_mode;
15224
15225 increment = 1;
15226
15227 maskcnt = 1;
15228 }
15229 }
15230 else
15231 {
15232 /**
15233 * generate full masks and charsets
15234 */
15235
15236 masks = (char **) mymalloc (sizeof (char *));
15237
15238 switch (hash_mode)
15239 {
15240 case 1731: pw_min = 5;
15241 pw_max = 5;
15242 mask = mystrdup ("?b?b?b?b?b");
15243 break;
15244 case 12500: pw_min = 5;
15245 pw_max = 5;
15246 mask = mystrdup ("?b?b?b?b?b");
15247 break;
15248 default: pw_min = 7;
15249 pw_max = 7;
15250 mask = mystrdup ("?b?b?b?b?b?b?b");
15251 break;
15252 }
15253
15254 maskcnt = 1;
15255
15256 masks[maskcnt - 1] = mystrdup (mask);
15257
15258 wordlist_mode = WL_MODE_MASK;
15259
15260 data.wordlist_mode = wordlist_mode;
15261
15262 increment = 1;
15263 }
15264
15265 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
15266
15267 if (increment)
15268 {
15269 if (increment_min > pw_min) pw_min = increment_min;
15270
15271 if (increment_max < pw_max) pw_max = increment_max;
15272 }
15273 }
15274 else if (attack_mode == ATTACK_MODE_HYBRID1)
15275 {
15276 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15277
15278 // display
15279
15280 char *mask = myargv[myargc - 1];
15281
15282 maskcnt = 0;
15283
15284 masks = (char **) mymalloc (1 * sizeof (char *));
15285
15286 // mod
15287
15288 struct stat file_stat;
15289
15290 if (stat (mask, &file_stat) == -1)
15291 {
15292 maskcnt = 1;
15293
15294 masks[maskcnt - 1] = mystrdup (mask);
15295 }
15296 else
15297 {
15298 uint is_file = S_ISREG (file_stat.st_mode);
15299
15300 if (is_file == 1)
15301 {
15302 FILE *mask_fp;
15303
15304 if ((mask_fp = fopen (mask, "r")) == NULL)
15305 {
15306 log_error ("ERROR: %s: %s", mask, strerror (errno));
15307
15308 return (-1);
15309 }
15310
15311 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15312
15313 uint masks_avail = 1;
15314
15315 while (!feof (mask_fp))
15316 {
15317 memset (line_buf, 0, HCBUFSIZ);
15318
15319 int line_len = fgetl (mask_fp, line_buf);
15320
15321 if (line_len == 0) continue;
15322
15323 if (line_buf[0] == '#') continue;
15324
15325 if (masks_avail == maskcnt)
15326 {
15327 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15328
15329 masks_avail += INCR_MASKS;
15330 }
15331
15332 masks[maskcnt] = mystrdup (line_buf);
15333
15334 maskcnt++;
15335 }
15336
15337 myfree (line_buf);
15338
15339 fclose (mask_fp);
15340
15341 mask_from_file = 1;
15342 }
15343 else
15344 {
15345 maskcnt = 1;
15346
15347 masks[maskcnt - 1] = mystrdup (mask);
15348 }
15349 }
15350
15351 // base
15352
15353 int wls_left = myargc - (optind + 2);
15354
15355 for (int i = 0; i < wls_left; i++)
15356 {
15357 char *filename = myargv[optind + 1 + i];
15358
15359 struct stat file_stat;
15360
15361 if (stat (filename, &file_stat) == -1)
15362 {
15363 log_error ("ERROR: %s: %s", filename, strerror (errno));
15364
15365 return (-1);
15366 }
15367
15368 uint is_dir = S_ISDIR (file_stat.st_mode);
15369
15370 if (is_dir == 0)
15371 {
15372 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15373
15374 dictcnt++;
15375
15376 dictfiles[dictcnt - 1] = filename;
15377 }
15378 else
15379 {
15380 // do not allow --keyspace w/ a directory
15381
15382 if (keyspace == 1)
15383 {
15384 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15385
15386 return (-1);
15387 }
15388
15389 char **dictionary_files = NULL;
15390
15391 dictionary_files = scan_directory (filename);
15392
15393 if (dictionary_files != NULL)
15394 {
15395 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15396
15397 for (int d = 0; dictionary_files[d] != NULL; d++)
15398 {
15399 char *l1_filename = dictionary_files[d];
15400
15401 struct stat l1_stat;
15402
15403 if (stat (l1_filename, &l1_stat) == -1)
15404 {
15405 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15406
15407 return (-1);
15408 }
15409
15410 if (S_ISREG (l1_stat.st_mode))
15411 {
15412 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15413
15414 dictcnt++;
15415
15416 dictfiles[dictcnt - 1] = strdup (l1_filename);
15417 }
15418 }
15419 }
15420
15421 local_free (dictionary_files);
15422 }
15423 }
15424
15425 if (dictcnt < 1)
15426 {
15427 log_error ("ERROR: No usable dictionary file found.");
15428
15429 return (-1);
15430 }
15431
15432 if (increment)
15433 {
15434 maskcnt = 0;
15435
15436 uint mask_min = increment_min; // we can't reject smaller masks here
15437 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15438
15439 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15440 {
15441 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15442
15443 if (cur_mask == NULL) break;
15444
15445 masks[maskcnt] = cur_mask;
15446
15447 maskcnt++;
15448
15449 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15450 }
15451 }
15452 }
15453 else if (attack_mode == ATTACK_MODE_HYBRID2)
15454 {
15455 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15456
15457 // display
15458
15459 char *mask = myargv[optind + 1 + 0];
15460
15461 maskcnt = 0;
15462
15463 masks = (char **) mymalloc (1 * sizeof (char *));
15464
15465 // mod
15466
15467 struct stat file_stat;
15468
15469 if (stat (mask, &file_stat) == -1)
15470 {
15471 maskcnt = 1;
15472
15473 masks[maskcnt - 1] = mystrdup (mask);
15474 }
15475 else
15476 {
15477 uint is_file = S_ISREG (file_stat.st_mode);
15478
15479 if (is_file == 1)
15480 {
15481 FILE *mask_fp;
15482
15483 if ((mask_fp = fopen (mask, "r")) == NULL)
15484 {
15485 log_error ("ERROR: %s: %s", mask, strerror (errno));
15486
15487 return (-1);
15488 }
15489
15490 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15491
15492 uint masks_avail = 1;
15493
15494 while (!feof (mask_fp))
15495 {
15496 memset (line_buf, 0, HCBUFSIZ);
15497
15498 int line_len = fgetl (mask_fp, line_buf);
15499
15500 if (line_len == 0) continue;
15501
15502 if (line_buf[0] == '#') continue;
15503
15504 if (masks_avail == maskcnt)
15505 {
15506 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15507
15508 masks_avail += INCR_MASKS;
15509 }
15510
15511 masks[maskcnt] = mystrdup (line_buf);
15512
15513 maskcnt++;
15514 }
15515
15516 myfree (line_buf);
15517
15518 fclose (mask_fp);
15519
15520 mask_from_file = 1;
15521 }
15522 else
15523 {
15524 maskcnt = 1;
15525
15526 masks[maskcnt - 1] = mystrdup (mask);
15527 }
15528 }
15529
15530 // base
15531
15532 int wls_left = myargc - (optind + 2);
15533
15534 for (int i = 0; i < wls_left; i++)
15535 {
15536 char *filename = myargv[optind + 2 + i];
15537
15538 struct stat file_stat;
15539
15540 if (stat (filename, &file_stat) == -1)
15541 {
15542 log_error ("ERROR: %s: %s", filename, strerror (errno));
15543
15544 return (-1);
15545 }
15546
15547 uint is_dir = S_ISDIR (file_stat.st_mode);
15548
15549 if (is_dir == 0)
15550 {
15551 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15552
15553 dictcnt++;
15554
15555 dictfiles[dictcnt - 1] = filename;
15556 }
15557 else
15558 {
15559 // do not allow --keyspace w/ a directory
15560
15561 if (keyspace == 1)
15562 {
15563 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15564
15565 return (-1);
15566 }
15567
15568 char **dictionary_files = NULL;
15569
15570 dictionary_files = scan_directory (filename);
15571
15572 if (dictionary_files != NULL)
15573 {
15574 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15575
15576 for (int d = 0; dictionary_files[d] != NULL; d++)
15577 {
15578 char *l1_filename = dictionary_files[d];
15579
15580 struct stat l1_stat;
15581
15582 if (stat (l1_filename, &l1_stat) == -1)
15583 {
15584 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15585
15586 return (-1);
15587 }
15588
15589 if (S_ISREG (l1_stat.st_mode))
15590 {
15591 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15592
15593 dictcnt++;
15594
15595 dictfiles[dictcnt - 1] = strdup (l1_filename);
15596 }
15597 }
15598 }
15599
15600 local_free (dictionary_files);
15601 }
15602 }
15603
15604 if (dictcnt < 1)
15605 {
15606 log_error ("ERROR: No usable dictionary file found.");
15607
15608 return (-1);
15609 }
15610
15611 if (increment)
15612 {
15613 maskcnt = 0;
15614
15615 uint mask_min = increment_min; // we can't reject smaller masks here
15616 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15617
15618 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15619 {
15620 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15621
15622 if (cur_mask == NULL) break;
15623
15624 masks[maskcnt] = cur_mask;
15625
15626 maskcnt++;
15627
15628 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15629 }
15630 }
15631 }
15632
15633 data.pw_min = pw_min;
15634 data.pw_max = pw_max;
15635
15636 /**
15637 * weak hash check
15638 */
15639
15640 if (weak_hash_threshold >= salts_cnt)
15641 {
15642 hc_device_param_t *device_param = NULL;
15643
15644 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15645 {
15646 device_param = &data.devices_param[device_id];
15647
15648 if (device_param->skipped) continue;
15649
15650 break;
15651 }
15652
15653 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15654
15655 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15656 {
15657 weak_hash_check (device_param, salt_pos);
15658 }
15659 }
15660
15661 // Display hack, guarantee that there is at least one \r before real start
15662
15663 if (data.quiet == 0) log_info_nn ("");
15664
15665 /**
15666 * status and monitor threads
15667 */
15668
15669 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15670
15671 hc_thread_t i_thread = 0;
15672
15673 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15674 {
15675 hc_thread_create (i_thread, thread_keypress, &benchmark);
15676 }
15677
15678 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15679
15680 uint ni_threads_cnt = 0;
15681
15682 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15683
15684 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15685
15686 ni_threads_cnt++;
15687
15688 /**
15689 * Outfile remove
15690 */
15691
15692 if (keyspace == 0)
15693 {
15694 if (outfile_check_timer != 0)
15695 {
15696 if (data.outfile_check_directory != NULL)
15697 {
15698 if ((hash_mode != 5200) &&
15699 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15700 (hash_mode != 9000))
15701 {
15702 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15703
15704 ni_threads_cnt++;
15705 }
15706 else
15707 {
15708 outfile_check_timer = 0;
15709 }
15710 }
15711 else
15712 {
15713 outfile_check_timer = 0;
15714 }
15715 }
15716 }
15717
15718 /**
15719 * Inform the user if we got some hashes remove because of the pot file remove feature
15720 */
15721
15722 if (data.quiet == 0)
15723 {
15724 if (potfile_remove_cracks > 0)
15725 {
15726 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15727 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15728 }
15729 }
15730
15731 data.outfile_check_timer = outfile_check_timer;
15732
15733 /**
15734 * main loop
15735 */
15736
15737 char **induction_dictionaries = NULL;
15738
15739 int induction_dictionaries_cnt = 0;
15740
15741 hcstat_table_t *root_table_buf = NULL;
15742 hcstat_table_t *markov_table_buf = NULL;
15743
15744 uint initial_restore_done = 0;
15745
15746 data.maskcnt = maskcnt;
15747
15748 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15749 {
15750 if (data.devices_status == STATUS_CRACKED) break;
15751
15752 data.devices_status = STATUS_INIT;
15753
15754 if (maskpos > rd->maskpos)
15755 {
15756 rd->dictpos = 0;
15757 }
15758
15759 rd->maskpos = maskpos;
15760 data.maskpos = maskpos;
15761
15762 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15763 {
15764 char *mask = masks[maskpos];
15765
15766 if (mask_from_file == 1)
15767 {
15768 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15769
15770 char *str_ptr;
15771 uint str_pos;
15772
15773 uint mask_offset = 0;
15774
15775 uint separator_cnt;
15776
15777 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15778 {
15779 str_ptr = strstr (mask + mask_offset, ",");
15780
15781 if (str_ptr == NULL) break;
15782
15783 str_pos = str_ptr - mask;
15784
15785 // escaped separator, i.e. "\,"
15786
15787 if (str_pos > 0)
15788 {
15789 if (mask[str_pos - 1] == '\\')
15790 {
15791 separator_cnt --;
15792
15793 mask_offset = str_pos + 1;
15794
15795 continue;
15796 }
15797 }
15798
15799 // reset the offset
15800
15801 mask_offset = 0;
15802
15803 mask[str_pos] = '\0';
15804
15805 switch (separator_cnt)
15806 {
15807 case 0:
15808 mp_reset_usr (mp_usr, 0);
15809
15810 custom_charset_1 = mask;
15811 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15812 break;
15813
15814 case 1:
15815 mp_reset_usr (mp_usr, 1);
15816
15817 custom_charset_2 = mask;
15818 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15819 break;
15820
15821 case 2:
15822 mp_reset_usr (mp_usr, 2);
15823
15824 custom_charset_3 = mask;
15825 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15826 break;
15827
15828 case 3:
15829 mp_reset_usr (mp_usr, 3);
15830
15831 custom_charset_4 = mask;
15832 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15833 break;
15834 }
15835
15836 mask = mask + str_pos + 1;
15837 }
15838 }
15839
15840 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15841 {
15842 if (maskpos > 0)
15843 {
15844 local_free (css_buf);
15845 local_free (data.root_css_buf);
15846 local_free (data.markov_css_buf);
15847
15848 local_free (masks[maskpos - 1]);
15849 }
15850
15851 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15852
15853 data.mask = mask;
15854 data.css_cnt = css_cnt;
15855 data.css_buf = css_buf;
15856
15857 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15858
15859 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15860
15861 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15862 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15863
15864 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15865
15866 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15867
15868 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15869 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15870
15871 data.root_css_buf = root_css_buf;
15872 data.markov_css_buf = markov_css_buf;
15873
15874 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15875
15876 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15877
15878 local_free (root_table_buf);
15879 local_free (markov_table_buf);
15880
15881 // args
15882
15883 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15884 {
15885 hc_device_param_t *device_param = &data.devices_param[device_id];
15886
15887 if (device_param->skipped) continue;
15888
15889 device_param->kernel_params_mp[0] = &device_param->d_combs;
15890 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15891 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15892
15893 device_param->kernel_params_mp_buf64[3] = 0;
15894 device_param->kernel_params_mp_buf32[4] = css_cnt;
15895 device_param->kernel_params_mp_buf32[5] = 0;
15896 device_param->kernel_params_mp_buf32[6] = 0;
15897 device_param->kernel_params_mp_buf32[7] = 0;
15898
15899 if (attack_mode == ATTACK_MODE_HYBRID1)
15900 {
15901 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15902 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15903 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15904 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15905 }
15906 else if (attack_mode == ATTACK_MODE_HYBRID2)
15907 {
15908 device_param->kernel_params_mp_buf32[5] = 0;
15909 device_param->kernel_params_mp_buf32[6] = 0;
15910 device_param->kernel_params_mp_buf32[7] = 0;
15911 }
15912
15913 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]);
15914 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]);
15915 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]);
15916
15917 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);
15918 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);
15919 }
15920 }
15921 else if (attack_mode == ATTACK_MODE_BF)
15922 {
15923 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15924
15925 if (increment)
15926 {
15927 for (uint i = 0; i < dictcnt; i++)
15928 {
15929 local_free (dictfiles[i]);
15930 }
15931
15932 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15933 {
15934 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15935
15936 if (l1_filename == NULL) break;
15937
15938 dictcnt++;
15939
15940 dictfiles[dictcnt - 1] = l1_filename;
15941 }
15942 }
15943 else
15944 {
15945 dictcnt++;
15946
15947 dictfiles[dictcnt - 1] = mask;
15948 }
15949
15950 if (dictcnt == 0)
15951 {
15952 log_error ("ERROR: Mask is too small");
15953
15954 return (-1);
15955 }
15956 }
15957 }
15958
15959 free (induction_dictionaries);
15960
15961 // induction_dictionaries_cnt = 0; // implied
15962
15963 if (attack_mode != ATTACK_MODE_BF)
15964 {
15965 if (keyspace == 0)
15966 {
15967 induction_dictionaries = scan_directory (induction_directory);
15968
15969 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15970 }
15971 }
15972
15973 if (induction_dictionaries_cnt)
15974 {
15975 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15976 }
15977
15978 /**
15979 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15980 */
15981 if (keyspace == 1)
15982 {
15983 if ((maskcnt > 1) || (dictcnt > 1))
15984 {
15985 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15986
15987 return (-1);
15988 }
15989 }
15990
15991 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15992 {
15993 char *subid = logfile_generate_subid ();
15994
15995 data.subid = subid;
15996
15997 logfile_sub_msg ("START");
15998
15999 data.devices_status = STATUS_INIT;
16000
16001 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
16002 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
16003 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
16004
16005 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
16006
16007 data.cpt_pos = 0;
16008
16009 data.cpt_start = time (NULL);
16010
16011 data.cpt_total = 0;
16012
16013 if (data.restore == 0)
16014 {
16015 rd->words_cur = skip;
16016
16017 skip = 0;
16018
16019 data.skip = 0;
16020 }
16021
16022 data.ms_paused = 0;
16023
16024 data.words_cur = rd->words_cur;
16025
16026 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16027 {
16028 hc_device_param_t *device_param = &data.devices_param[device_id];
16029
16030 if (device_param->skipped) continue;
16031
16032 device_param->speed_pos = 0;
16033
16034 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
16035 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
16036 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
16037
16038 device_param->speed_cnt_total = 0;
16039 device_param->speed_ms_total = 0;
16040
16041 device_param->exec_pos = 0;
16042
16043 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
16044
16045 device_param->kernel_power = device_param->kernel_power_user;
16046
16047 device_param->outerloop_pos = 0;
16048 device_param->outerloop_left = 0;
16049 device_param->innerloop_pos = 0;
16050 device_param->innerloop_left = 0;
16051
16052 // some more resets:
16053
16054 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
16055
16056 device_param->pws_cnt = 0;
16057
16058 device_param->words_off = 0;
16059 device_param->words_done = 0;
16060 }
16061
16062 data.kernel_power_div = 0;
16063
16064 // figure out some workload
16065
16066 if (attack_mode == ATTACK_MODE_STRAIGHT)
16067 {
16068 if (data.wordlist_mode == WL_MODE_FILE)
16069 {
16070 char *dictfile = NULL;
16071
16072 if (induction_dictionaries_cnt)
16073 {
16074 dictfile = induction_dictionaries[0];
16075 }
16076 else
16077 {
16078 dictfile = dictfiles[dictpos];
16079 }
16080
16081 data.dictfile = dictfile;
16082
16083 logfile_sub_string (dictfile);
16084
16085 for (uint i = 0; i < rp_files_cnt; i++)
16086 {
16087 logfile_sub_var_string ("rulefile", rp_files[i]);
16088 }
16089
16090 FILE *fd2 = fopen (dictfile, "rb");
16091
16092 if (fd2 == NULL)
16093 {
16094 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16095
16096 return (-1);
16097 }
16098
16099 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16100
16101 fclose (fd2);
16102
16103 if (data.words_cnt == 0)
16104 {
16105 if (data.devices_status == STATUS_CRACKED) break;
16106 if (data.devices_status == STATUS_ABORTED) break;
16107
16108 dictpos++;
16109
16110 continue;
16111 }
16112 }
16113 }
16114 else if (attack_mode == ATTACK_MODE_COMBI)
16115 {
16116 char *dictfile = data.dictfile;
16117 char *dictfile2 = data.dictfile2;
16118
16119 logfile_sub_string (dictfile);
16120 logfile_sub_string (dictfile2);
16121
16122 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
16123 {
16124 FILE *fd2 = fopen (dictfile, "rb");
16125
16126 if (fd2 == NULL)
16127 {
16128 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16129
16130 return (-1);
16131 }
16132
16133 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16134
16135 fclose (fd2);
16136 }
16137 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
16138 {
16139 FILE *fd2 = fopen (dictfile2, "rb");
16140
16141 if (fd2 == NULL)
16142 {
16143 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16144
16145 return (-1);
16146 }
16147
16148 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
16149
16150 fclose (fd2);
16151 }
16152
16153 if (data.words_cnt == 0)
16154 {
16155 if (data.devices_status == STATUS_CRACKED) break;
16156 if (data.devices_status == STATUS_ABORTED) break;
16157
16158 dictpos++;
16159
16160 continue;
16161 }
16162 }
16163 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16164 {
16165 char *dictfile = NULL;
16166
16167 if (induction_dictionaries_cnt)
16168 {
16169 dictfile = induction_dictionaries[0];
16170 }
16171 else
16172 {
16173 dictfile = dictfiles[dictpos];
16174 }
16175
16176 data.dictfile = dictfile;
16177
16178 char *mask = data.mask;
16179
16180 logfile_sub_string (dictfile);
16181 logfile_sub_string (mask);
16182
16183 FILE *fd2 = fopen (dictfile, "rb");
16184
16185 if (fd2 == NULL)
16186 {
16187 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16188
16189 return (-1);
16190 }
16191
16192 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16193
16194 fclose (fd2);
16195
16196 if (data.words_cnt == 0)
16197 {
16198 if (data.devices_status == STATUS_CRACKED) break;
16199 if (data.devices_status == STATUS_ABORTED) break;
16200
16201 dictpos++;
16202
16203 continue;
16204 }
16205 }
16206 else if (attack_mode == ATTACK_MODE_BF)
16207 {
16208 local_free (css_buf);
16209 local_free (data.root_css_buf);
16210 local_free (data.markov_css_buf);
16211
16212 char *mask = dictfiles[dictpos];
16213
16214 logfile_sub_string (mask);
16215
16216 // base
16217
16218 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16219
16220 if (opts_type & OPTS_TYPE_PT_UNICODE)
16221 {
16222 uint css_cnt_unicode = css_cnt * 2;
16223
16224 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
16225
16226 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
16227 {
16228 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
16229
16230 css_buf_unicode[j + 1].cs_buf[0] = 0;
16231 css_buf_unicode[j + 1].cs_len = 1;
16232 }
16233
16234 free (css_buf);
16235
16236 css_buf = css_buf_unicode;
16237 css_cnt = css_cnt_unicode;
16238 }
16239
16240 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
16241
16242 uint mask_min = pw_min;
16243 uint mask_max = pw_max;
16244
16245 if (opts_type & OPTS_TYPE_PT_UNICODE)
16246 {
16247 mask_min *= 2;
16248 mask_max *= 2;
16249 }
16250
16251 if ((css_cnt < mask_min) || (css_cnt > mask_max))
16252 {
16253 if (css_cnt < mask_min)
16254 {
16255 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
16256 }
16257
16258 if (css_cnt > mask_max)
16259 {
16260 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
16261 }
16262
16263 // skip to next mask
16264
16265 dictpos++;
16266
16267 rd->dictpos = dictpos;
16268
16269 logfile_sub_msg ("STOP");
16270
16271 continue;
16272 }
16273
16274 uint save_css_cnt = css_cnt;
16275
16276 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16277 {
16278 if (opti_type & OPTI_TYPE_APPENDED_SALT)
16279 {
16280 uint salt_len = (uint) data.salts_buf[0].salt_len;
16281 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
16282
16283 uint css_cnt_salt = css_cnt + salt_len;
16284
16285 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
16286
16287 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
16288
16289 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
16290 {
16291 css_buf_salt[j].cs_buf[0] = salt_buf[i];
16292 css_buf_salt[j].cs_len = 1;
16293 }
16294
16295 free (css_buf);
16296
16297 css_buf = css_buf_salt;
16298 css_cnt = css_cnt_salt;
16299 }
16300 }
16301
16302 data.mask = mask;
16303 data.css_cnt = css_cnt;
16304 data.css_buf = css_buf;
16305
16306 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
16307
16308 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16309
16310 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16311
16312 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16313 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16314
16315 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16316
16317 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16318
16319 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16320 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16321
16322 data.root_css_buf = root_css_buf;
16323 data.markov_css_buf = markov_css_buf;
16324
16325 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16326
16327 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16328
16329 local_free (root_table_buf);
16330 local_free (markov_table_buf);
16331
16332 // copy + args
16333
16334 uint css_cnt_l = css_cnt;
16335 uint css_cnt_r;
16336
16337 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16338 {
16339 if (save_css_cnt < 6)
16340 {
16341 css_cnt_r = 1;
16342 }
16343 else if (save_css_cnt == 6)
16344 {
16345 css_cnt_r = 2;
16346 }
16347 else
16348 {
16349 if (opts_type & OPTS_TYPE_PT_UNICODE)
16350 {
16351 if (save_css_cnt == 8 || save_css_cnt == 10)
16352 {
16353 css_cnt_r = 2;
16354 }
16355 else
16356 {
16357 css_cnt_r = 4;
16358 }
16359 }
16360 else
16361 {
16362 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
16363 {
16364 css_cnt_r = 3;
16365 }
16366 else
16367 {
16368 css_cnt_r = 4;
16369 }
16370 }
16371 }
16372 }
16373 else
16374 {
16375 css_cnt_r = 1;
16376
16377 /* unfinished code?
16378 int sum = css_buf[css_cnt_r - 1].cs_len;
16379
16380 for (uint i = 1; i < 4 && i < css_cnt; i++)
16381 {
16382 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
16383
16384 css_cnt_r++;
16385
16386 sum *= css_buf[css_cnt_r - 1].cs_len;
16387 }
16388 */
16389 }
16390
16391 css_cnt_l -= css_cnt_r;
16392
16393 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
16394
16395 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16396 {
16397 hc_device_param_t *device_param = &data.devices_param[device_id];
16398
16399 if (device_param->skipped) continue;
16400
16401 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
16402 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
16403 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
16404
16405 device_param->kernel_params_mp_l_buf64[3] = 0;
16406 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
16407 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
16408 device_param->kernel_params_mp_l_buf32[6] = 0;
16409 device_param->kernel_params_mp_l_buf32[7] = 0;
16410 device_param->kernel_params_mp_l_buf32[8] = 0;
16411
16412 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
16413 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
16414 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
16415 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
16416
16417 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
16418 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
16419 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
16420
16421 device_param->kernel_params_mp_r_buf64[3] = 0;
16422 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
16423 device_param->kernel_params_mp_r_buf32[5] = 0;
16424 device_param->kernel_params_mp_r_buf32[6] = 0;
16425 device_param->kernel_params_mp_r_buf32[7] = 0;
16426
16427 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]);
16428 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]);
16429 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]);
16430
16431 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]);
16432 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]);
16433 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]);
16434
16435 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);
16436 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);
16437 }
16438 }
16439
16440 u64 words_base = data.words_cnt;
16441
16442 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16443 {
16444 if (data.kernel_rules_cnt)
16445 {
16446 words_base /= data.kernel_rules_cnt;
16447 }
16448 }
16449 else if (data.attack_kern == ATTACK_KERN_COMBI)
16450 {
16451 if (data.combs_cnt)
16452 {
16453 words_base /= data.combs_cnt;
16454 }
16455 }
16456 else if (data.attack_kern == ATTACK_KERN_BF)
16457 {
16458 if (data.bfs_cnt)
16459 {
16460 words_base /= data.bfs_cnt;
16461 }
16462 }
16463
16464 data.words_base = words_base;
16465
16466 if (keyspace == 1)
16467 {
16468 log_info ("%llu", (unsigned long long int) words_base);
16469
16470 return (0);
16471 }
16472
16473 if (data.words_cur > data.words_base)
16474 {
16475 log_error ("ERROR: restore value greater keyspace");
16476
16477 return (-1);
16478 }
16479
16480 if (data.words_cur)
16481 {
16482 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16483 {
16484 for (uint i = 0; i < data.salts_cnt; i++)
16485 {
16486 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16487 }
16488 }
16489 else if (data.attack_kern == ATTACK_KERN_COMBI)
16490 {
16491 for (uint i = 0; i < data.salts_cnt; i++)
16492 {
16493 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16494 }
16495 }
16496 else if (data.attack_kern == ATTACK_KERN_BF)
16497 {
16498 for (uint i = 0; i < data.salts_cnt; i++)
16499 {
16500 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16501 }
16502 }
16503 }
16504
16505 /*
16506 * Inform user about possible slow speeds
16507 */
16508
16509 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16510 {
16511 if (data.words_base < kernel_power_all)
16512 {
16513 if (quiet == 0)
16514 {
16515 log_info ("");
16516 log_info ("ATTENTION!");
16517 log_info (" The wordlist or mask you are using is too small.");
16518 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
16519 log_info (" The cracking speed will drop.");
16520 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16521 log_info ("");
16522 }
16523 }
16524 }
16525
16526 /*
16527 * Update loopback file
16528 */
16529
16530 if (loopback == 1)
16531 {
16532 time_t now;
16533
16534 time (&now);
16535
16536 uint random_num = get_random_num (0, 9999);
16537
16538 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16539
16540 data.loopback_file = loopback_file;
16541 }
16542
16543 /*
16544 * Update dictionary statistic
16545 */
16546
16547 if (keyspace == 0)
16548 {
16549 dictstat_fp = fopen (dictstat, "wb");
16550
16551 if (dictstat_fp)
16552 {
16553 lock_file (dictstat_fp);
16554
16555 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16556
16557 fclose (dictstat_fp);
16558 }
16559 }
16560
16561 data.devices_status = STATUS_RUNNING;
16562
16563 if (initial_restore_done == 0)
16564 {
16565 if (data.restore_disable == 0) cycle_restore ();
16566
16567 initial_restore_done = 1;
16568 }
16569
16570 hc_timer_set (&data.timer_running);
16571
16572 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16573 {
16574 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16575 {
16576 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16577 if (quiet == 0) fflush (stdout);
16578 }
16579 }
16580 else if (wordlist_mode == WL_MODE_STDIN)
16581 {
16582 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16583 if (data.quiet == 0) log_info ("");
16584 }
16585
16586 time_t runtime_start;
16587
16588 time (&runtime_start);
16589
16590 data.runtime_start = runtime_start;
16591
16592 /**
16593 * create cracker threads
16594 */
16595
16596 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
16597
16598 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16599 {
16600 hc_device_param_t *device_param = &devices_param[device_id];
16601
16602 if (wordlist_mode == WL_MODE_STDIN)
16603 {
16604 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16605 }
16606 else
16607 {
16608 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16609 }
16610 }
16611
16612 // wait for crack threads to exit
16613
16614 hc_thread_wait (data.devices_cnt, c_threads);
16615
16616 local_free (c_threads);
16617
16618 data.restore = 0;
16619
16620 // finalize task
16621
16622 logfile_sub_var_uint ("status-after-work", data.devices_status);
16623
16624 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16625
16626 if (data.devices_status == STATUS_CRACKED) break;
16627 if (data.devices_status == STATUS_ABORTED) break;
16628
16629 if (data.devices_status == STATUS_BYPASS)
16630 {
16631 data.devices_status = STATUS_RUNNING;
16632 }
16633
16634 if (induction_dictionaries_cnt)
16635 {
16636 unlink (induction_dictionaries[0]);
16637 }
16638
16639 free (induction_dictionaries);
16640
16641 if (attack_mode != ATTACK_MODE_BF)
16642 {
16643 induction_dictionaries = scan_directory (induction_directory);
16644
16645 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16646 }
16647
16648 if (benchmark == 0)
16649 {
16650 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16651 {
16652 if (quiet == 0) clear_prompt ();
16653
16654 if (quiet == 0) log_info ("");
16655
16656 if (status == 1)
16657 {
16658 status_display ();
16659 }
16660 else
16661 {
16662 if (quiet == 0) status_display ();
16663 }
16664
16665 if (quiet == 0) log_info ("");
16666 }
16667 }
16668
16669 if (attack_mode == ATTACK_MODE_BF)
16670 {
16671 dictpos++;
16672
16673 rd->dictpos = dictpos;
16674 }
16675 else
16676 {
16677 if (induction_dictionaries_cnt)
16678 {
16679 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16680 }
16681 else
16682 {
16683 dictpos++;
16684
16685 rd->dictpos = dictpos;
16686 }
16687 }
16688
16689 time_t runtime_stop;
16690
16691 time (&runtime_stop);
16692
16693 data.runtime_stop = runtime_stop;
16694
16695 logfile_sub_uint (runtime_start);
16696 logfile_sub_uint (runtime_stop);
16697
16698 logfile_sub_msg ("STOP");
16699
16700 global_free (subid);
16701 }
16702
16703 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16704
16705 if (data.devices_status == STATUS_CRACKED) break;
16706 if (data.devices_status == STATUS_ABORTED) break;
16707 if (data.devices_status == STATUS_QUIT) break;
16708
16709 if (data.devices_status == STATUS_BYPASS)
16710 {
16711 data.devices_status = STATUS_RUNNING;
16712 }
16713 }
16714
16715 // 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
16716
16717 if (attack_mode == ATTACK_MODE_STRAIGHT)
16718 {
16719 if (data.wordlist_mode == WL_MODE_FILE)
16720 {
16721 if (data.dictfile == NULL)
16722 {
16723 if (dictfiles != NULL)
16724 {
16725 data.dictfile = dictfiles[0];
16726
16727 hc_timer_set (&data.timer_running);
16728 }
16729 }
16730 }
16731 }
16732 // NOTE: combi is okay because it is already set beforehand
16733 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16734 {
16735 if (data.dictfile == NULL)
16736 {
16737 if (dictfiles != NULL)
16738 {
16739 hc_timer_set (&data.timer_running);
16740
16741 data.dictfile = dictfiles[0];
16742 }
16743 }
16744 }
16745 else if (attack_mode == ATTACK_MODE_BF)
16746 {
16747 if (data.mask == NULL)
16748 {
16749 hc_timer_set (&data.timer_running);
16750
16751 data.mask = masks[0];
16752 }
16753 }
16754
16755 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16756 {
16757 data.devices_status = STATUS_EXHAUSTED;
16758 }
16759
16760 // if cracked / aborted remove last induction dictionary
16761
16762 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16763 {
16764 struct stat induct_stat;
16765
16766 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16767 {
16768 unlink (induction_dictionaries[file_pos]);
16769 }
16770 }
16771
16772 // wait for non-interactive threads
16773
16774 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16775 {
16776 hc_thread_wait (1, &ni_threads[thread_idx]);
16777 }
16778
16779 local_free (ni_threads);
16780
16781 // wait for interactive threads
16782
16783 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16784 {
16785 hc_thread_wait (1, &i_thread);
16786 }
16787
16788 // we dont need restore file anymore
16789 if (data.restore_disable == 0)
16790 {
16791 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16792 {
16793 unlink (eff_restore_file);
16794 unlink (new_restore_file);
16795 }
16796 else
16797 {
16798 cycle_restore ();
16799 }
16800 }
16801
16802 // finally save left hashes
16803
16804 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16805 {
16806 save_hash ();
16807 }
16808
16809 /**
16810 * Clean up
16811 */
16812
16813 if (benchmark == 1)
16814 {
16815 status_benchmark ();
16816
16817 log_info ("");
16818 }
16819 else
16820 {
16821 if (quiet == 0) clear_prompt ();
16822
16823 if (quiet == 0) log_info ("");
16824
16825 if (status == 1)
16826 {
16827 status_display ();
16828 }
16829 else
16830 {
16831 if (quiet == 0) status_display ();
16832 }
16833
16834 if (quiet == 0) log_info ("");
16835 }
16836
16837 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16838 {
16839 hc_device_param_t *device_param = &data.devices_param[device_id];
16840
16841 if (device_param->skipped) continue;
16842
16843 local_free (device_param->result);
16844
16845 local_free (device_param->combs_buf);
16846
16847 local_free (device_param->hooks_buf);
16848
16849 local_free (device_param->device_name);
16850
16851 local_free (device_param->device_name_chksum);
16852
16853 local_free (device_param->device_version);
16854
16855 local_free (device_param->driver_version);
16856
16857 if (device_param->pws_buf) myfree (device_param->pws_buf);
16858 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
16859 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
16860 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
16861 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
16862 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
16863 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
16864 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
16865 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
16866 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
16867 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
16868 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
16869 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
16870 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
16871 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
16872 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
16873 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
16874 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
16875 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
16876 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
16877 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
16878 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
16879 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
16880 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
16881 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
16882 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
16883 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
16884 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
16885 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
16886
16887 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
16888 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
16889 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
16890 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
16891 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
16892 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
16893 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
16894 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
16895 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
16896 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
16897
16898 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
16899 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
16900 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
16901
16902 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
16903 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
16904 }
16905
16906 // reset default fan speed
16907
16908 #ifdef HAVE_HWMON
16909 if (gpu_temp_disable == 0)
16910 {
16911 #ifdef HAVE_ADL
16912 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16913 {
16914 hc_thread_mutex_lock (mux_adl);
16915
16916 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16917 {
16918 hc_device_param_t *device_param = &data.devices_param[device_id];
16919
16920 if (device_param->skipped) continue;
16921
16922 if (data.hm_device[device_id].fan_supported == 1)
16923 {
16924 int fanspeed = temp_retain_fanspeed_value[device_id];
16925
16926 if (fanspeed == -1) continue;
16927
16928 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
16929
16930 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
16931 }
16932 }
16933
16934 hc_thread_mutex_unlock (mux_adl);
16935 }
16936 #endif // HAVE_ADL
16937 }
16938
16939 #ifdef HAVE_ADL
16940 // reset power tuning
16941
16942 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16943 {
16944 hc_thread_mutex_lock (mux_adl);
16945
16946 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16947 {
16948 hc_device_param_t *device_param = &data.devices_param[device_id];
16949
16950 if (device_param->skipped) continue;
16951
16952 if (data.hm_device[device_id].od_version == 6)
16953 {
16954 // check powertune capabilities first, if not available then skip device
16955
16956 int powertune_supported = 0;
16957
16958 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
16959 {
16960 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16961
16962 return (-1);
16963 }
16964
16965 if (powertune_supported != 0)
16966 {
16967 // powercontrol settings
16968
16969 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)
16970 {
16971 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16972
16973 return (-1);
16974 }
16975
16976 // clocks
16977
16978 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16979
16980 performance_state->iNumberOfPerformanceLevels = 2;
16981
16982 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
16983 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
16984 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
16985 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
16986
16987 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)
16988 {
16989 log_info ("ERROR: Failed to restore ADL performance state");
16990
16991 return (-1);
16992 }
16993
16994 local_free (performance_state);
16995 }
16996 }
16997 }
16998
16999 hc_thread_mutex_unlock (mux_adl);
17000 }
17001 #endif // HAVE_ADL
17002
17003 if (gpu_temp_disable == 0)
17004 {
17005 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
17006 if (data.hm_nv)
17007 {
17008 #if defined(LINUX) && defined(HAVE_NVML)
17009
17010 hm_NVML_nvmlShutdown (data.hm_nv);
17011
17012 nvml_close (data.hm_nv);
17013
17014 #elif defined(WIN) && (HAVE_NVAPI)
17015
17016 hm_NvAPI_Unload (data.hm_nv);
17017
17018 nvapi_close (data.hm_nv);
17019
17020 #endif
17021
17022 data.hm_nv = NULL;
17023 }
17024 #endif
17025
17026 #ifdef HAVE_ADL
17027 if (data.hm_amd)
17028 {
17029 hm_ADL_Main_Control_Destroy (data.hm_amd);
17030
17031 adl_close (data.hm_amd);
17032 data.hm_amd = NULL;
17033 }
17034 #endif
17035 }
17036 #endif // HAVE_HWMON
17037
17038 // free memory
17039
17040 local_free (masks);
17041
17042 local_free (dictstat_base);
17043
17044 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
17045 {
17046 pot_t *pot_ptr = &pot[pot_pos];
17047
17048 hash_t *hash = &pot_ptr->hash;
17049
17050 local_free (hash->digest);
17051
17052 if (isSalted)
17053 {
17054 local_free (hash->salt);
17055 }
17056 }
17057
17058 local_free (pot);
17059
17060 local_free (all_kernel_rules_cnt);
17061 local_free (all_kernel_rules_buf);
17062
17063 local_free (wl_data->buf);
17064 local_free (wl_data);
17065
17066 local_free (bitmap_s1_a);
17067 local_free (bitmap_s1_b);
17068 local_free (bitmap_s1_c);
17069 local_free (bitmap_s1_d);
17070 local_free (bitmap_s2_a);
17071 local_free (bitmap_s2_b);
17072 local_free (bitmap_s2_c);
17073 local_free (bitmap_s2_d);
17074
17075 #ifdef HAVE_HWMON
17076 local_free (temp_retain_fanspeed_value);
17077 #ifdef HAVE_ADL
17078 local_free (od_clock_mem_status);
17079 local_free (od_power_control_status);
17080 #endif // ADL
17081 #endif
17082
17083 global_free (devices_param);
17084
17085 global_free (kernel_rules_buf);
17086
17087 global_free (root_css_buf);
17088 global_free (markov_css_buf);
17089
17090 global_free (digests_buf);
17091 global_free (digests_shown);
17092 global_free (digests_shown_tmp);
17093
17094 global_free (salts_buf);
17095 global_free (salts_shown);
17096
17097 global_free (esalts_buf);
17098
17099 global_free (words_progress_done);
17100 global_free (words_progress_rejected);
17101 global_free (words_progress_restored);
17102
17103 if (pot_fp) fclose (pot_fp);
17104
17105 if (data.devices_status == STATUS_QUIT) break;
17106 }
17107
17108 // destroy others mutex
17109
17110 hc_thread_mutex_delete (mux_dispatcher);
17111 hc_thread_mutex_delete (mux_counter);
17112 hc_thread_mutex_delete (mux_display);
17113 hc_thread_mutex_delete (mux_adl);
17114
17115 // free memory
17116
17117 local_free (eff_restore_file);
17118 local_free (new_restore_file);
17119
17120 local_free (rd);
17121
17122 // tuning db
17123
17124 tuning_db_destroy (tuning_db);
17125
17126 // loopback
17127
17128 local_free (loopback_file);
17129
17130 if (loopback == 1) unlink (loopback_file);
17131
17132 // induction directory
17133
17134 if (induction_dir == NULL)
17135 {
17136 if (attack_mode != ATTACK_MODE_BF)
17137 {
17138 if (rmdir (induction_directory) == -1)
17139 {
17140 if (errno == ENOENT)
17141 {
17142 // good, we can ignore
17143 }
17144 else if (errno == ENOTEMPTY)
17145 {
17146 // good, we can ignore
17147 }
17148 else
17149 {
17150 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
17151
17152 return (-1);
17153 }
17154 }
17155
17156 local_free (induction_directory);
17157 }
17158 }
17159
17160 // outfile-check directory
17161
17162 if (outfile_check_dir == NULL)
17163 {
17164 if (rmdir (outfile_check_directory) == -1)
17165 {
17166 if (errno == ENOENT)
17167 {
17168 // good, we can ignore
17169 }
17170 else if (errno == ENOTEMPTY)
17171 {
17172 // good, we can ignore
17173 }
17174 else
17175 {
17176 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
17177
17178 return (-1);
17179 }
17180 }
17181
17182 local_free (outfile_check_directory);
17183 }
17184
17185 time_t proc_stop;
17186
17187 time (&proc_stop);
17188
17189 logfile_top_uint (proc_start);
17190 logfile_top_uint (proc_stop);
17191
17192 logfile_top_msg ("STOP");
17193
17194 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
17195 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
17196
17197 if (data.ocl) ocl_close (data.ocl);
17198
17199 if (data.devices_status == STATUS_ABORTED) return 2;
17200 if (data.devices_status == STATUS_QUIT) return 2;
17201 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
17202 if (data.devices_status == STATUS_EXHAUSTED) return 1;
17203 if (data.devices_status == STATUS_CRACKED) return 0;
17204
17205 return -1;
17206 }
Hashcat additions to support pwdhash