projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Add platform vendor_id detection
[hashcat.git] / src / oclHashcat.c
1 /**
2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
5 *
6 * License.....: MIT
7 */
8
9 #ifdef OSX
10 #include <stdio.h>
11 #endif
12
13 #include <common.h>
14 #include <shared.h>
15 #include <rp_kernel_on_cpu.h>
16 #include <getopt.h>
17
18 const char *PROGNAME = "oclHashcat";
19 const uint VERSION_BIN = 210;
20 const uint RESTORE_MIN = 210;
21
22 double TARGET_MS_PROFILE[3] = { 8, 16, 96 };
23
24 #define INCR_RULES 10000
25 #define INCR_SALTS 100000
26 #define INCR_MASKS 1000
27 #define INCR_POT 1000
28
29 #define USAGE 0
30 #define VERSION 0
31 #define QUIET 0
32 #define MARKOV_THRESHOLD 0
33 #define MARKOV_DISABLE 0
34 #define MARKOV_CLASSIC 0
35 #define BENCHMARK 0
36 #define BENCHMARK_REPEATS 100
37 #define RESTORE 0
38 #define RESTORE_TIMER 60
39 #define RESTORE_DISABLE 0
40 #define STATUS 0
41 #define STATUS_TIMER 10
42 #define STATUS_AUTOMAT 0
43 #define LOOPBACK 0
44 #define WEAK_HASH_THRESHOLD 100
45 #define SHOW 0
46 #define LEFT 0
47 #define USERNAME 0
48 #define REMOVE 0
49 #define REMOVE_TIMER 60
50 #define SKIP 0
51 #define LIMIT 0
52 #define KEYSPACE 0
53 #define POTFILE_DISABLE 0
54 #define DEBUG_MODE 0
55 #define RP_GEN 0
56 #define RP_GEN_FUNC_MIN 1
57 #define RP_GEN_FUNC_MAX 4
58 #define RP_GEN_SEED 0
59 #define RULE_BUF_L ":"
60 #define RULE_BUF_R ":"
61 #define FORCE 0
62 #define RUNTIME 0
63 #define HEX_CHARSET 0
64 #define HEX_SALT 0
65 #define HEX_WORDLIST 0
66 #define OUTFILE_FORMAT 3
67 #define OUTFILE_AUTOHEX 1
68 #define OUTFILE_CHECK_TIMER 5
69 #define ATTACK_MODE 0
70 #define HASH_MODE 0
71 #define SEGMENT_SIZE 32
72 #define INCREMENT 0
73 #define INCREMENT_MIN 1
74 #define INCREMENT_MAX PW_MAX
75 #define SEPARATOR ':'
76 #define BITMAP_MIN 16
77 #define BITMAP_MAX 24
78 #define GPU_TEMP_DISABLE 0
79 #define GPU_TEMP_ABORT 90
80 #define GPU_TEMP_RETAIN 80
81 #define WORKLOAD_PROFILE 2
82 #define KERNEL_ACCEL 0
83 #define KERNEL_LOOPS 0
84 #define KERNEL_RULES 1024
85 #define KERNEL_COMBS 1024
86 #define KERNEL_BFS 1024
87 #define KERNEL_THREADS 64
88 #define POWERTUNE_ENABLE 0
89 #define LOGFILE_DISABLE 0
90 #define SCRYPT_TMTO 0
91 #define OPENCL_VECTOR_WIDTH 0
92
93 #define WL_MODE_STDIN 1
94 #define WL_MODE_FILE 2
95 #define WL_MODE_MASK 3
96
97 #define HL_MODE_FILE 4
98 #define HL_MODE_ARG 5
99
100 #define HLFMTS_CNT 11
101 #define HLFMT_HASHCAT 0
102 #define HLFMT_PWDUMP 1
103 #define HLFMT_PASSWD 2
104 #define HLFMT_SHADOW 3
105 #define HLFMT_DCC 4
106 #define HLFMT_DCC2 5
107 #define HLFMT_NETNTLM1 7
108 #define HLFMT_NETNTLM2 8
109 #define HLFMT_NSLDAP 9
110 #define HLFMT_NSLDAPS 10
111
112 #define HLFMT_TEXT_HASHCAT "native hashcat"
113 #define HLFMT_TEXT_PWDUMP "pwdump"
114 #define HLFMT_TEXT_PASSWD "passwd"
115 #define HLFMT_TEXT_SHADOW "shadow"
116 #define HLFMT_TEXT_DCC "DCC"
117 #define HLFMT_TEXT_DCC2 "DCC 2"
118 #define HLFMT_TEXT_NETNTLM1 "NetNTLMv1"
119 #define HLFMT_TEXT_NETNTLM2 "NetNTLMv2"
120 #define HLFMT_TEXT_NSLDAP "nsldap"
121 #define HLFMT_TEXT_NSLDAPS "nsldaps"
122
123 #define ATTACK_MODE_STRAIGHT 0
124 #define ATTACK_MODE_COMBI 1
125 #define ATTACK_MODE_TOGGLE 2
126 #define ATTACK_MODE_BF 3
127 #define ATTACK_MODE_PERM 4
128 #define ATTACK_MODE_TABLE 5
129 #define ATTACK_MODE_HYBRID1 6
130 #define ATTACK_MODE_HYBRID2 7
131 #define ATTACK_MODE_NONE 100
132
133 #define ATTACK_KERN_STRAIGHT 0
134 #define ATTACK_KERN_COMBI 1
135 #define ATTACK_KERN_BF 3
136 #define ATTACK_KERN_NONE 100
137
138 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
139 #define ATTACK_EXEC_INSIDE_KERNEL 11
140
141 #define COMBINATOR_MODE_BASE_LEFT 10001
142 #define COMBINATOR_MODE_BASE_RIGHT 10002
143
144 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
145 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
146
147 #define MAX_CUT_TRIES 4
148
149 #define MAX_DICTSTAT 10000
150
151 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 135
152
153 #define global_free(attr) \
154 { \
155 myfree ((void *) data.attr); \
156 \
157 data.attr = NULL; \
158 }
159
160 #define local_free(attr) \
161 { \
162 myfree ((void *) attr); \
163 \
164 attr = NULL; \
165 }
166
167 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
168 {
169 900,
170 0,
171 5100,
172 100,
173 1400,
174 10800,
175 1700,
176 5000,
177 10100,
178 6000,
179 6100,
180 6900,
181 11700,
182 11800,
183 400,
184 8900,
185 11900,
186 12000,
187 10900,
188 12100,
189 23,
190 2500,
191 5300,
192 5400,
193 5500,
194 5600,
195 7300,
196 7500,
197 13100,
198 8300,
199 11100,
200 11200,
201 11400,
202 121,
203 2611,
204 2711,
205 2811,
206 8400,
207 11,
208 2612,
209 7900,
210 21,
211 11000,
212 124,
213 10000,
214 3711,
215 7600,
216 12,
217 131,
218 132,
219 1731,
220 200,
221 300,
222 3100,
223 112,
224 12300,
225 8000,
226 141,
227 1441,
228 1600,
229 12600,
230 1421,
231 101,
232 111,
233 1711,
234 3000,
235 1000,
236 1100,
237 2100,
238 12800,
239 1500,
240 12400,
241 500,
242 3200,
243 7400,
244 1800,
245 122,
246 1722,
247 7100,
248 6300,
249 6700,
250 6400,
251 6500,
252 2400,
253 2410,
254 5700,
255 9200,
256 9300,
257 22,
258 501,
259 5800,
260 8100,
261 8500,
262 7200,
263 9900,
264 7700,
265 7800,
266 10300,
267 8600,
268 8700,
269 9100,
270 133,
271 11600,
272 12500,
273 13000,
274 13200,
275 13300,
276 6211,
277 6221,
278 6231,
279 6241,
280 8800,
281 12900,
282 12200,
283 9700,
284 9710,
285 9800,
286 9810,
287 9400,
288 9500,
289 9600,
290 10400,
291 10410,
292 10500,
293 10600,
294 10700,
295 9000,
296 5200,
297 6800,
298 6600,
299 8200,
300 11300,
301 12700,
302 13400,
303 125
304 };
305
306 /**
307 * types
308 */
309
310 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
311
312 /**
313 * globals
314 */
315
316 static unsigned int full01 = 0x01010101;
317 static unsigned int full80 = 0x80808080;
318
319 int SUPPRESS_OUTPUT = 0;
320
321 hc_thread_mutex_t mux_adl;
322 hc_thread_mutex_t mux_counter;
323 hc_thread_mutex_t mux_dispatcher;
324 hc_thread_mutex_t mux_display;
325
326 hc_global_data_t data;
327
328 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
329
330 const char *USAGE_MINI[] =
331 {
332 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
333 "",
334 "Try --help for more help.",
335 NULL
336 };
337
338 const char *USAGE_BIG[] =
339 {
340 "%s, advanced password recovery",
341 "",
342 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
343 "",
344 "=======",
345 "Options",
346 "=======",
347 "",
348 "* General:",
349 "",
350 " -m, --hash-type=NUM Hash-type, see references below",
351 " -a, --attack-mode=NUM Attack-mode, see references below",
352 " -V, --version Print version",
353 " -h, --help Print help",
354 " --quiet Suppress output",
355 "",
356 "* Misc:",
357 "",
358 " --hex-charset Assume charset is given in hex",
359 " --hex-salt Assume salt is given in hex",
360 " --hex-wordlist Assume words in wordlist is given in hex",
361 " --force Ignore warnings",
362 " --status Enable automatic update of the status-screen",
363 " --status-timer=NUM Seconds between status-screen update",
364 " --status-automat Display the status view in a machine readable format",
365 " --loopback Add new plains to induct directory",
366 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
367 "",
368 "* Markov:",
369 "",
370 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
371 " --markov-disable Disables markov-chains, emulates classic brute-force",
372 " --markov-classic Enables classic markov-chains, no per-position enhancement",
373 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
374 "",
375 "* Session:",
376 "",
377 " --runtime=NUM Abort session after NUM seconds of runtime",
378 " --session=STR Define specific session name",
379 " --restore Restore session from --session",
380 " --restore-disable Do not write restore file",
381 "",
382 "* Files:",
383 "",
384 " -o, --outfile=FILE Define outfile for recovered hash",
385 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
386 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
387 " --outfile-check-timer=NUM Seconds between outfile checks",
388 " -p, --separator=CHAR Separator char for hashlists and outfile",
389 " --show Show cracked passwords only",
390 " --left Show un-cracked passwords only",
391 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
392 " --remove Enable remove of hash once it is cracked",
393 " --remove-timer=NUM Update input hash file each NUM seconds",
394 " --potfile-disable Do not write potfile",
395 " --potfile-path Specific path to potfile",
396 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
397 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
398 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
399 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
400 " --logfile-disable Disable the logfile",
401 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
402 "",
403 "* Resources:",
404 "",
405 " -b, --benchmark Run benchmark",
406 " --benchmark-repeats=NUM Repeat the kernel on the device NUM times to increase benchmark accuracy",
407 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
408 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
409 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
410 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
411 " --opencl-platforms=STR OpenCL platforms to use, separate with comma",
412 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
413 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
414 " --opencl-vector-width=NUM OpenCL vector-width (either 1, 2, 4, 8 or 16), overrides value from device query",
415 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
416 " -n, --kernel-accel=NUM Workload tuning, increase the outer-loop step size",
417 " -u, --kernel-loops=NUM Workload tuning, increase the inner-loop step size",
418 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
419 #ifdef HAVE_HWMON
420 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
421 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
422 #ifdef HAVE_ADL
423 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
424 #endif
425 #endif
426 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
427 "",
428 "* Distributed:",
429 "",
430 " -s, --skip=NUM Skip number of words",
431 " -l, --limit=NUM Limit number of words",
432 " --keyspace Show keyspace base:mod values and quit",
433 "",
434 "* Rules:",
435 "",
436 " -j, --rule-left=RULE Single rule applied to each word from left dict",
437 " -k, --rule-right=RULE Single rule applied to each word from right dict",
438 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
439 " -g, --generate-rules=NUM Generate NUM random rules",
440 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
441 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
442 " --generate-rules-seed=NUM Force RNG seed to NUM",
443 "",
444 "* Custom charsets:",
445 "",
446 " -1, --custom-charset1=CS User-defined charsets",
447 " -2, --custom-charset2=CS Example:",
448 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
449 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
450 "",
451 "* Increment:",
452 "",
453 " -i, --increment Enable increment mode",
454 " --increment-min=NUM Start incrementing at NUM",
455 " --increment-max=NUM Stop incrementing at NUM",
456 "",
457 "==========",
458 "References",
459 "==========",
460 "",
461 "* Workload Profile:",
462 "",
463 " 1 = Interactive performance profile, kernel execution runtime to 8ms, lower latency desktop, lower speed",
464 " 2 = Default performance profile, kernel execution runtime to 16ms, economic setting",
465 " 3 = Headless performance profile, kernel execution runtime to 96ms, higher latency desktop, higher speed",
466 "",
467 "* OpenCL device-types:",
468 "",
469 " 1 = CPU devices",
470 " 2 = GPU devices",
471 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
472 "",
473 "* Outfile Formats:",
474 "",
475 " 1 = hash[:salt]",
476 " 2 = plain",
477 " 3 = hash[:salt]:plain",
478 " 4 = hex_plain",
479 " 5 = hash[:salt]:hex_plain",
480 " 6 = plain:hex_plain",
481 " 7 = hash[:salt]:plain:hex_plain",
482 " 8 = crackpos",
483 " 9 = hash[:salt]:crackpos",
484 " 10 = plain:crackpos",
485 " 11 = hash[:salt]:plain:crackpos",
486 " 12 = hex_plain:crackpos",
487 " 13 = hash[:salt]:hex_plain:crackpos",
488 " 14 = plain:hex_plain:crackpos",
489 " 15 = hash[:salt]:plain:hex_plain:crackpos",
490 "",
491 "* Debug mode output formats (for hybrid mode only, by using rules):",
492 "",
493 " 1 = save finding rule",
494 " 2 = save original word",
495 " 3 = save original word and finding rule",
496 " 4 = save original word, finding rule and modified plain",
497 "",
498 "* Built-in charsets:",
499 "",
500 " ?l = abcdefghijklmnopqrstuvwxyz",
501 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
502 " ?d = 0123456789",
503 " ?s = !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
504 " ?a = ?l?u?d?s",
505 " ?b = 0x00 - 0xff",
506 "",
507 "* Attack modes:",
508 "",
509 " 0 = Straight",
510 " 1 = Combination",
511 " 3 = Brute-force",
512 " 6 = Hybrid dict + mask",
513 " 7 = Hybrid mask + dict",
514 "",
515 "* Hash types:",
516 "",
517 "[[ Roll-your-own: Raw Hashes ]]",
518 "",
519 " 900 = MD4",
520 " 0 = MD5",
521 " 5100 = Half MD5",
522 " 100 = SHA1",
523 " 10800 = SHA-384",
524 " 1400 = SHA-256",
525 " 1700 = SHA-512",
526 " 5000 = SHA-3(Keccak)",
527 " 10100 = SipHash",
528 " 6000 = RipeMD160",
529 " 6100 = Whirlpool",
530 " 6900 = GOST R 34.11-94",
531 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
532 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
533 "",
534 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
535 "",
536 " 10 = md5($pass.$salt)",
537 " 20 = md5($salt.$pass)",
538 " 30 = md5(unicode($pass).$salt)",
539 " 40 = md5($salt.unicode($pass))",
540 " 3800 = md5($salt.$pass.$salt)",
541 " 3710 = md5($salt.md5($pass))",
542 " 2600 = md5(md5($pass)",
543 " 4300 = md5(strtoupper(md5($pass)))",
544 " 4400 = md5(sha1($pass))",
545 " 110 = sha1($pass.$salt)",
546 " 120 = sha1($salt.$pass)",
547 " 130 = sha1(unicode($pass).$salt)",
548 " 140 = sha1($salt.unicode($pass))",
549 " 4500 = sha1(sha1($pass)",
550 " 4700 = sha1(md5($pass))",
551 " 4900 = sha1($salt.$pass.$salt)",
552 " 1410 = sha256($pass.$salt)",
553 " 1420 = sha256($salt.$pass)",
554 " 1430 = sha256(unicode($pass).$salt)",
555 " 1440 = sha256($salt.unicode($pass))",
556 " 1710 = sha512($pass.$salt)",
557 " 1720 = sha512($salt.$pass)",
558 " 1730 = sha512(unicode($pass).$salt)",
559 " 1740 = sha512($salt.unicode($pass))",
560 "",
561 "[[ Roll-your-own: Authenticated Hashes ]]",
562 "",
563 " 50 = HMAC-MD5 (key = $pass)",
564 " 60 = HMAC-MD5 (key = $salt)",
565 " 150 = HMAC-SHA1 (key = $pass)",
566 " 160 = HMAC-SHA1 (key = $salt)",
567 " 1450 = HMAC-SHA256 (key = $pass)",
568 " 1460 = HMAC-SHA256 (key = $salt)",
569 " 1750 = HMAC-SHA512 (key = $pass)",
570 " 1760 = HMAC-SHA512 (key = $salt)",
571 "",
572 "[[ Generic KDF ]]",
573 "",
574 " 400 = phpass",
575 " 8900 = scrypt",
576 " 11900 = PBKDF2-HMAC-MD5",
577 " 12000 = PBKDF2-HMAC-SHA1",
578 " 10900 = PBKDF2-HMAC-SHA256",
579 " 12100 = PBKDF2-HMAC-SHA512",
580 "",
581 "[[ Network protocols, Challenge-Response ]]",
582 "",
583 " 23 = Skype",
584 " 2500 = WPA/WPA2",
585 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
586 " 5300 = IKE-PSK MD5",
587 " 5400 = IKE-PSK SHA1",
588 " 5500 = NetNTLMv1",
589 " 5500 = NetNTLMv1 + ESS",
590 " 5600 = NetNTLMv2",
591 " 7300 = IPMI2 RAKP HMAC-SHA1",
592 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
593 " 8300 = DNSSEC (NSEC3)",
594 " 10200 = Cram MD5",
595 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
596 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
597 " 11400 = SIP digest authentication (MD5)",
598 " 13100 = Kerberos 5 TGS-REP etype 23",
599 "",
600 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
601 "",
602 " 121 = SMF (Simple Machines Forum)",
603 " 400 = phpBB3",
604 " 2611 = vBulletin < v3.8.5",
605 " 2711 = vBulletin > v3.8.5",
606 " 2811 = MyBB",
607 " 2811 = IPB (Invison Power Board)",
608 " 8400 = WBB3 (Woltlab Burning Board)",
609 " 11 = Joomla < 2.5.18",
610 " 400 = Joomla > 2.5.18",
611 " 400 = Wordpress",
612 " 2612 = PHPS",
613 " 7900 = Drupal7",
614 " 21 = osCommerce",
615 " 21 = xt:Commerce",
616 " 11000 = PrestaShop",
617 " 124 = Django (SHA-1)",
618 " 10000 = Django (PBKDF2-SHA256)",
619 " 3711 = Mediawiki B type",
620 " 7600 = Redmine",
621 "",
622 "[[ Database Server ]]",
623 "",
624 " 12 = PostgreSQL",
625 " 131 = MSSQL(2000)",
626 " 132 = MSSQL(2005)",
627 " 1731 = MSSQL(2012)",
628 " 1731 = MSSQL(2014)",
629 " 200 = MySQL323",
630 " 300 = MySQL4.1/MySQL5",
631 " 3100 = Oracle H: Type (Oracle 7+)",
632 " 112 = Oracle S: Type (Oracle 11+)",
633 " 12300 = Oracle T: Type (Oracle 12+)",
634 " 8000 = Sybase ASE",
635 "",
636 "[[ HTTP, SMTP, LDAP Server ]]",
637 "",
638 " 141 = EPiServer 6.x < v4",
639 " 1441 = EPiServer 6.x > v4",
640 " 1600 = Apache $apr1$",
641 " 12600 = ColdFusion 10+",
642 " 1421 = hMailServer",
643 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
644 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
645 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
646 "",
647 "[[ Checksums ]]",
648 "",
649 " 11500 = CRC32",
650 "",
651 "[[ Operating-Systems ]]",
652 "",
653 " 3000 = LM",
654 " 1000 = NTLM",
655 " 1100 = Domain Cached Credentials (DCC), MS Cache",
656 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
657 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
658 " 1500 = descrypt, DES(Unix), Traditional DES",
659 " 12400 = BSDiCrypt, Extended DES",
660 " 500 = md5crypt $1$, MD5(Unix)",
661 " 3200 = bcrypt $2*$, Blowfish(Unix)",
662 " 7400 = sha256crypt $5$, SHA256(Unix)",
663 " 1800 = sha512crypt $6$, SHA512(Unix)",
664 " 122 = OSX v10.4",
665 " 122 = OSX v10.5",
666 " 122 = OSX v10.6",
667 " 1722 = OSX v10.7",
668 " 7100 = OSX v10.8",
669 " 7100 = OSX v10.9",
670 " 7100 = OSX v10.10",
671 " 6300 = AIX {smd5}",
672 " 6700 = AIX {ssha1}",
673 " 6400 = AIX {ssha256}",
674 " 6500 = AIX {ssha512}",
675 " 2400 = Cisco-PIX",
676 " 2410 = Cisco-ASA",
677 " 500 = Cisco-IOS $1$",
678 " 5700 = Cisco-IOS $4$",
679 " 9200 = Cisco-IOS $8$",
680 " 9300 = Cisco-IOS $9$",
681 " 22 = Juniper Netscreen/SSG (ScreenOS)",
682 " 501 = Juniper IVE",
683 " 5800 = Android PIN",
684 " 8100 = Citrix Netscaler",
685 " 8500 = RACF",
686 " 7200 = GRUB 2",
687 " 9900 = Radmin2",
688 " 125 = ArubaOS",
689 "",
690 "[[ Enterprise Application Software (EAS) ]]",
691 "",
692 " 7700 = SAP CODVN B (BCODE)",
693 " 7800 = SAP CODVN F/G (PASSCODE)",
694 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
695 " 8600 = Lotus Notes/Domino 5",
696 " 8700 = Lotus Notes/Domino 6",
697 " 9100 = Lotus Notes/Domino 8",
698 " 133 = PeopleSoft",
699 "",
700 "[[ Archives ]]",
701 "",
702 " 11600 = 7-Zip",
703 " 12500 = RAR3-hp",
704 " 13000 = RAR5",
705 " 13200 = AxCrypt",
706 " 13300 = AxCrypt in memory SHA1",
707 "",
708 "[[ Full-Disk encryptions (FDE) ]]",
709 "",
710 " 62XY = TrueCrypt 5.0+",
711 " X = 1 = PBKDF2-HMAC-RipeMD160",
712 " X = 2 = PBKDF2-HMAC-SHA512",
713 " X = 3 = PBKDF2-HMAC-Whirlpool",
714 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
715 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
716 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
717 " Y = 3 = XTS 1536 bit (Ciphers: All)",
718 " 8800 = Android FDE < v4.3",
719 " 12900 = Android FDE (Samsung DEK)",
720 " 12200 = eCryptfs",
721 "",
722 "[[ Documents ]]",
723 "",
724 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
725 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
726 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
727 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
728 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
729 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
730 " 9400 = MS Office 2007",
731 " 9500 = MS Office 2010",
732 " 9600 = MS Office 2013",
733 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
734 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
735 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
736 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
737 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
738 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
739 "",
740 "[[ Password Managers ]]",
741 "",
742 " 9000 = Password Safe v2",
743 " 5200 = Password Safe v3",
744 " 6800 = Lastpass",
745 " 6600 = 1Password, agilekeychain",
746 " 8200 = 1Password, cloudkeychain",
747 " 11300 = Bitcoin/Litecoin wallet.dat",
748 " 12700 = Blockchain, My Wallet",
749 " 13400 = Keepass 1 (AES/Twofish) and Keepass 2 (AES)",
750 "",
751 NULL
752 };
753
754 /**
755 * oclHashcat specific functions
756 */
757
758 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
759 {
760 int exec_pos = (int) device_param->exec_pos - last_num_entries;
761
762 if (exec_pos < 0) exec_pos += EXEC_CACHE;
763
764 double exec_ms_sum = 0;
765
766 int exec_ms_cnt = 0;
767
768 for (int i = 0; i < last_num_entries; i++)
769 {
770 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
771
772 if (exec_ms)
773 {
774 exec_ms_sum += exec_ms;
775
776 exec_ms_cnt++;
777 }
778 }
779
780 if (exec_ms_cnt == 0) return 0;
781
782 return exec_ms_sum / exec_ms_cnt;
783 }
784
785 void status_display_automat ()
786 {
787 FILE *out = stdout;
788
789 fprintf (out, "STATUS\t%u\t", data.devices_status);
790
791 /**
792 * speed new
793 */
794
795 fprintf (out, "SPEED\t");
796
797 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
798 {
799 hc_device_param_t *device_param = &data.devices_param[device_id];
800
801 if (device_param->skipped) continue;
802
803 u64 speed_cnt = 0;
804 double speed_ms = 0;
805
806 for (int i = 0; i < SPEED_CACHE; i++)
807 {
808 speed_cnt += device_param->speed_cnt[i];
809 speed_ms += device_param->speed_ms[i];
810 }
811
812 speed_cnt /= SPEED_CACHE;
813 speed_ms /= SPEED_CACHE;
814
815 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
816 }
817
818 /**
819 * exec time
820 */
821
822 fprintf (out, "EXEC_RUNTIME\t");
823
824 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
825 {
826 hc_device_param_t *device_param = &data.devices_param[device_id];
827
828 if (device_param->skipped) continue;
829
830 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
831
832 fprintf (out, "%f\t", exec_ms_avg);
833 }
834
835 /**
836 * words_cur
837 */
838
839 u64 words_cur = get_lowest_words_done ();
840
841 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
842
843 /**
844 * counter
845 */
846
847 u64 progress_total = data.words_cnt * data.salts_cnt;
848
849 u64 all_done = 0;
850 u64 all_rejected = 0;
851 u64 all_restored = 0;
852
853 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
854 {
855 all_done += data.words_progress_done[salt_pos];
856 all_rejected += data.words_progress_rejected[salt_pos];
857 all_restored += data.words_progress_restored[salt_pos];
858 }
859
860 u64 progress_cur = all_restored + all_done + all_rejected;
861 u64 progress_end = progress_total;
862
863 u64 progress_skip = 0;
864
865 if (data.skip)
866 {
867 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
868
869 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
870 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
871 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
872 }
873
874 if (data.limit)
875 {
876 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
877
878 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
879 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
880 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
881 }
882
883 u64 progress_cur_relative_skip = progress_cur - progress_skip;
884 u64 progress_end_relative_skip = progress_end - progress_skip;
885
886 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
887
888 /**
889 * cracks
890 */
891
892 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
893 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
894
895 /**
896 * temperature
897 */
898
899 #ifdef HAVE_HWMON
900 if (data.gpu_temp_disable == 0)
901 {
902 fprintf (out, "TEMP\t");
903
904 hc_thread_mutex_lock (mux_adl);
905
906 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
907 {
908 hc_device_param_t *device_param = &data.devices_param[device_id];
909
910 if (device_param->skipped) continue;
911
912 int temp = hm_get_temperature_with_device_id (device_id);
913
914 fprintf (out, "%d\t", temp);
915 }
916
917 hc_thread_mutex_unlock (mux_adl);
918 }
919 #endif // HAVE_HWMON
920
921 /**
922 * flush
923 */
924
925 #ifdef _WIN
926 fputc ('\r', out);
927 fputc ('\n', out);
928 #endif
929
930 #ifdef _POSIX
931 fputc ('\n', out);
932 #endif
933
934 fflush (out);
935 }
936
937 void status_display ()
938 {
939 if (data.devices_status == STATUS_INIT) return;
940 if (data.devices_status == STATUS_STARTING) return;
941 if (data.devices_status == STATUS_BYPASS) return;
942
943 if (data.status_automat == 1)
944 {
945 status_display_automat ();
946
947 return;
948 }
949
950 char tmp_buf[1000] = { 0 };
951
952 uint tmp_len = 0;
953
954 log_info ("Session.Name...: %s", data.session);
955
956 char *status_type = strstatus (data.devices_status);
957
958 uint hash_mode = data.hash_mode;
959
960 char *hash_type = strhashtype (hash_mode); // not a bug
961
962 log_info ("Status.........: %s", status_type);
963
964 /**
965 * show rules
966 */
967
968 if (data.rp_files_cnt)
969 {
970 uint i;
971
972 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
973 {
974 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
975 }
976
977 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
978
979 log_info ("Rules.Type.....: %s", tmp_buf);
980
981 tmp_len = 0;
982 }
983
984 if (data.rp_gen)
985 {
986 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
987
988 if (data.rp_gen_seed)
989 {
990 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
991 }
992 }
993
994 /**
995 * show input
996 */
997
998 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
999 {
1000 if (data.wordlist_mode == WL_MODE_FILE)
1001 {
1002 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
1003 }
1004 else if (data.wordlist_mode == WL_MODE_STDIN)
1005 {
1006 log_info ("Input.Mode.....: Pipe");
1007 }
1008 }
1009 else if (data.attack_mode == ATTACK_MODE_COMBI)
1010 {
1011 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1012 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1013 }
1014 else if (data.attack_mode == ATTACK_MODE_BF)
1015 {
1016 char *mask = data.mask;
1017
1018 if (mask != NULL)
1019 {
1020 uint mask_len = data.css_cnt;
1021
1022 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1023
1024 if (mask_len > 0)
1025 {
1026 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1027 {
1028 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1029 {
1030 mask_len -= data.salts_buf[0].salt_len;
1031 }
1032 }
1033
1034 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1035
1036 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1037 }
1038
1039 if (data.maskcnt > 1)
1040 {
1041 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1042
1043 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1044 }
1045
1046 log_info ("Input.Mode.....: %s", tmp_buf);
1047 }
1048
1049 tmp_len = 0;
1050 }
1051 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1052 {
1053 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1054 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1055 }
1056 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1057 {
1058 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1059 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1060 }
1061
1062 if (data.digests_cnt == 1)
1063 {
1064 if (data.hash_mode == 2500)
1065 {
1066 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1067
1068 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1069 (char *) data.salts_buf[0].salt_buf,
1070 wpa->orig_mac1[0],
1071 wpa->orig_mac1[1],
1072 wpa->orig_mac1[2],
1073 wpa->orig_mac1[3],
1074 wpa->orig_mac1[4],
1075 wpa->orig_mac1[5],
1076 wpa->orig_mac2[0],
1077 wpa->orig_mac2[1],
1078 wpa->orig_mac2[2],
1079 wpa->orig_mac2[3],
1080 wpa->orig_mac2[4],
1081 wpa->orig_mac2[5]);
1082 }
1083 else if (data.hash_mode == 5200)
1084 {
1085 log_info ("Hash.Target....: File (%s)", data.hashfile);
1086 }
1087 else if (data.hash_mode == 9000)
1088 {
1089 log_info ("Hash.Target....: File (%s)", data.hashfile);
1090 }
1091 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1092 {
1093 log_info ("Hash.Target....: File (%s)", data.hashfile);
1094 }
1095 else
1096 {
1097 char out_buf[HCBUFSIZ] = { 0 };
1098
1099 ascii_digest (out_buf, 0, 0);
1100
1101 // limit length
1102 if (strlen (out_buf) > 40)
1103 {
1104 out_buf[41] = '.';
1105 out_buf[42] = '.';
1106 out_buf[43] = '.';
1107 out_buf[44] = 0;
1108 }
1109
1110 log_info ("Hash.Target....: %s", out_buf);
1111 }
1112 }
1113 else
1114 {
1115 if (data.hash_mode == 3000)
1116 {
1117 char out_buf1[32] = { 0 };
1118 char out_buf2[32] = { 0 };
1119
1120 ascii_digest (out_buf1, 0, 0);
1121 ascii_digest (out_buf2, 0, 1);
1122
1123 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1124 }
1125 else
1126 {
1127 log_info ("Hash.Target....: File (%s)", data.hashfile);
1128 }
1129 }
1130
1131 log_info ("Hash.Type......: %s", hash_type);
1132
1133 /**
1134 * speed new
1135 */
1136
1137 u64 speed_cnt[DEVICES_MAX] = { 0 };
1138 double speed_ms[DEVICES_MAX] = { 0 };
1139
1140 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1141 {
1142 hc_device_param_t *device_param = &data.devices_param[device_id];
1143
1144 if (device_param->skipped) continue;
1145
1146 speed_cnt[device_id] = 0;
1147 speed_ms[device_id] = 0;
1148
1149 for (int i = 0; i < SPEED_CACHE; i++)
1150 {
1151 speed_cnt[device_id] += device_param->speed_cnt[i];
1152 speed_ms[device_id] += device_param->speed_ms[i];
1153 }
1154
1155 speed_cnt[device_id] /= SPEED_CACHE;
1156 speed_ms[device_id] /= SPEED_CACHE;
1157 }
1158
1159 float hashes_all_ms = 0;
1160
1161 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1162
1163 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1164 {
1165 hc_device_param_t *device_param = &data.devices_param[device_id];
1166
1167 if (device_param->skipped) continue;
1168
1169 hashes_dev_ms[device_id] = 0;
1170
1171 if (speed_ms[device_id])
1172 {
1173 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1174
1175 hashes_all_ms += hashes_dev_ms[device_id];
1176 }
1177 }
1178
1179 /**
1180 * exec time
1181 */
1182
1183 double exec_all_ms[DEVICES_MAX] = { 0 };
1184
1185 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1186 {
1187 hc_device_param_t *device_param = &data.devices_param[device_id];
1188
1189 if (device_param->skipped) continue;
1190
1191 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1192
1193 exec_all_ms[device_id] = exec_ms_avg;
1194 }
1195
1196 /**
1197 * timers
1198 */
1199
1200 double ms_running = 0;
1201
1202 hc_timer_get (data.timer_running, ms_running);
1203
1204 double ms_paused = data.ms_paused;
1205
1206 if (data.devices_status == STATUS_PAUSED)
1207 {
1208 double ms_paused_tmp = 0;
1209
1210 hc_timer_get (data.timer_paused, ms_paused_tmp);
1211
1212 ms_paused += ms_paused_tmp;
1213 }
1214
1215 #ifdef WIN
1216
1217 __time64_t sec_run = ms_running / 1000;
1218
1219 #else
1220
1221 time_t sec_run = ms_running / 1000;
1222
1223 #endif
1224
1225 if (sec_run)
1226 {
1227 char display_run[32] = { 0 };
1228
1229 struct tm tm_run;
1230
1231 struct tm *tmp = NULL;
1232
1233 #ifdef WIN
1234
1235 tmp = _gmtime64 (&sec_run);
1236
1237 #else
1238
1239 tmp = gmtime (&sec_run);
1240
1241 #endif
1242
1243 if (tmp != NULL)
1244 {
1245 memset (&tm_run, 0, sizeof (tm_run));
1246
1247 memcpy (&tm_run, tmp, sizeof (tm_run));
1248
1249 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1250
1251 char *start = ctime (&data.proc_start);
1252
1253 size_t start_len = strlen (start);
1254
1255 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1256 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1257
1258 log_info ("Time.Started...: %s (%s)", start, display_run);
1259 }
1260 }
1261 else
1262 {
1263 log_info ("Time.Started...: 0 secs");
1264 }
1265
1266 /**
1267 * counters
1268 */
1269
1270 u64 progress_total = data.words_cnt * data.salts_cnt;
1271
1272 u64 all_done = 0;
1273 u64 all_rejected = 0;
1274 u64 all_restored = 0;
1275
1276 u64 progress_noneed = 0;
1277
1278 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1279 {
1280 all_done += data.words_progress_done[salt_pos];
1281 all_rejected += data.words_progress_rejected[salt_pos];
1282 all_restored += data.words_progress_restored[salt_pos];
1283
1284 // Important for ETA only
1285
1286 if (data.salts_shown[salt_pos] == 1)
1287 {
1288 const u64 all = data.words_progress_done[salt_pos]
1289 + data.words_progress_rejected[salt_pos]
1290 + data.words_progress_restored[salt_pos];
1291
1292 const u64 left = data.words_cnt - all;
1293
1294 progress_noneed += left;
1295 }
1296 }
1297
1298 u64 progress_cur = all_restored + all_done + all_rejected;
1299 u64 progress_end = progress_total;
1300
1301 u64 progress_skip = 0;
1302
1303 if (data.skip)
1304 {
1305 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1306
1307 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1308 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1309 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1310 }
1311
1312 if (data.limit)
1313 {
1314 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1315
1316 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1317 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1318 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1319 }
1320
1321 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1322 u64 progress_end_relative_skip = progress_end - progress_skip;
1323
1324 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1325 {
1326 if (data.devices_status != STATUS_CRACKED)
1327 {
1328 #ifdef WIN
1329 __time64_t sec_etc = 0;
1330 #else
1331 time_t sec_etc = 0;
1332 #endif
1333
1334 if (hashes_all_ms)
1335 {
1336 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1337
1338 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1339
1340 sec_etc = ms_left / 1000;
1341 }
1342
1343 if (sec_etc == 0)
1344 {
1345 //log_info ("Time.Estimated.: 0 secs");
1346 }
1347 else if ((u64) sec_etc > ETC_MAX)
1348 {
1349 log_info ("Time.Estimated.: > 10 Years");
1350 }
1351 else
1352 {
1353 char display_etc[32] = { 0 };
1354
1355 struct tm tm_etc;
1356
1357 struct tm *tmp = NULL;
1358
1359 #ifdef WIN
1360
1361 tmp = _gmtime64 (&sec_etc);
1362
1363 #else
1364
1365 tmp = gmtime (&sec_etc);
1366
1367 #endif
1368
1369 if (tmp != NULL)
1370 {
1371 memset (&tm_etc, 0, sizeof (tm_etc));
1372
1373 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1374
1375 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1376
1377 time_t now;
1378
1379 time (&now);
1380
1381 now += sec_etc;
1382
1383 char *etc = ctime (&now);
1384
1385 size_t etc_len = strlen (etc);
1386
1387 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1388 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1389
1390 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1391 }
1392 }
1393 }
1394 }
1395
1396 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1397 {
1398 hc_device_param_t *device_param = &data.devices_param[device_id];
1399
1400 if (device_param->skipped) continue;
1401
1402 char display_dev_cur[16] = { 0 };
1403
1404 strncpy (display_dev_cur, "0.00", 4);
1405
1406 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1407
1408 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1409 }
1410
1411 char display_all_cur[16] = { 0 };
1412
1413 strncpy (display_all_cur, "0.00", 4);
1414
1415 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1416
1417 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1418
1419 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1420 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1421
1422 log_info ("Recovered......: %u/%u (%.2f%%) Digests, %u/%u (%.2f%%) Salts", data.digests_done, data.digests_cnt, digests_percent * 100, data.salts_done, data.salts_cnt, salts_percent * 100);
1423
1424 // crack-per-time
1425
1426 if (data.digests_cnt > 100)
1427 {
1428 time_t now = time (NULL);
1429
1430 int cpt_cur_min = 0;
1431 int cpt_cur_hour = 0;
1432 int cpt_cur_day = 0;
1433
1434 for (int i = 0; i < CPT_BUF; i++)
1435 {
1436 const uint cracked = data.cpt_buf[i].cracked;
1437 const time_t timestamp = data.cpt_buf[i].timestamp;
1438
1439 if ((timestamp + 60) > now)
1440 {
1441 cpt_cur_min += cracked;
1442 }
1443
1444 if ((timestamp + 3600) > now)
1445 {
1446 cpt_cur_hour += cracked;
1447 }
1448
1449 if ((timestamp + 86400) > now)
1450 {
1451 cpt_cur_day += cracked;
1452 }
1453 }
1454
1455 double ms_real = ms_running - ms_paused;
1456
1457 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1458 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1459 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1460
1461 if ((data.cpt_start + 86400) < now)
1462 {
1463 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1464 cpt_cur_min,
1465 cpt_cur_hour,
1466 cpt_cur_day,
1467 cpt_avg_min,
1468 cpt_avg_hour,
1469 cpt_avg_day);
1470 }
1471 else if ((data.cpt_start + 3600) < now)
1472 {
1473 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1474 cpt_cur_min,
1475 cpt_cur_hour,
1476 cpt_avg_min,
1477 cpt_avg_hour,
1478 cpt_avg_day);
1479 }
1480 else if ((data.cpt_start + 60) < now)
1481 {
1482 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1483 cpt_cur_min,
1484 cpt_avg_min,
1485 cpt_avg_hour,
1486 cpt_avg_day);
1487 }
1488 else
1489 {
1490 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1491 cpt_avg_min,
1492 cpt_avg_hour,
1493 cpt_avg_day);
1494 }
1495 }
1496
1497 // Restore point
1498
1499 u64 restore_point = get_lowest_words_done ();
1500
1501 u64 restore_total = data.words_base;
1502
1503 float percent_restore = 0;
1504
1505 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1506
1507 if (progress_end_relative_skip)
1508 {
1509 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1510 {
1511 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1512 float percent_rejected = 0.0;
1513
1514 if (progress_cur)
1515 {
1516 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1517 }
1518
1519 log_info ("Progress.......: %llu/%llu (%.02f%%)", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip, percent_finished * 100);
1520 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1521
1522 if (data.restore_disable == 0)
1523 {
1524 if (percent_finished != 1)
1525 {
1526 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1527 }
1528 }
1529 }
1530 }
1531 else
1532 {
1533 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1534 {
1535 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1536 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1537
1538 if (data.restore_disable == 0)
1539 {
1540 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1541 }
1542 }
1543 else
1544 {
1545 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1546 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1547
1548 // --restore not allowed if stdin is used -- really? why?
1549
1550 //if (data.restore_disable == 0)
1551 //{
1552 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1553 //}
1554 }
1555 }
1556
1557 #ifdef HAVE_HWMON
1558 if (data.gpu_temp_disable == 0)
1559 {
1560 hc_thread_mutex_lock (mux_adl);
1561
1562 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1563 {
1564 hc_device_param_t *device_param = &data.devices_param[device_id];
1565
1566 if (device_param->skipped) continue;
1567
1568 #define HM_STR_BUF_SIZE 255
1569
1570 if (data.hm_device[device_id].fan_supported == 1)
1571 {
1572 char utilization[HM_STR_BUF_SIZE] = { 0 };
1573 char temperature[HM_STR_BUF_SIZE] = { 0 };
1574 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1575
1576 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1577 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1578
1579 if (device_param->vendor_id == VENDOR_ID_AMD)
1580 {
1581 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1582 }
1583 else if (device_param->vendor_id == VENDOR_ID_NV)
1584 {
1585 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1586 }
1587
1588 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1589 }
1590 else
1591 {
1592 char utilization[HM_STR_BUF_SIZE] = { 0 };
1593 char temperature[HM_STR_BUF_SIZE] = { 0 };
1594
1595 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1596 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1597
1598 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1599 }
1600 }
1601
1602 hc_thread_mutex_unlock (mux_adl);
1603 }
1604 #endif // HAVE_HWMON
1605 }
1606
1607 static void status_benchmark ()
1608 {
1609 if (data.devices_status == STATUS_INIT) return;
1610 if (data.devices_status == STATUS_STARTING) return;
1611
1612 if (data.words_cnt == 0) return;
1613
1614 u64 speed_cnt[DEVICES_MAX] = { 0 };
1615 double speed_ms[DEVICES_MAX] = { 0 };
1616
1617 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1618 {
1619 hc_device_param_t *device_param = &data.devices_param[device_id];
1620
1621 if (device_param->skipped) continue;
1622
1623 speed_cnt[device_id] = device_param->speed_cnt[0];
1624 speed_ms[device_id] = device_param->speed_ms[0];
1625 }
1626
1627 float hashes_all_ms = 0;
1628
1629 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1630
1631 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1632 {
1633 hc_device_param_t *device_param = &data.devices_param[device_id];
1634
1635 if (device_param->skipped) continue;
1636
1637 hashes_dev_ms[device_id] = 0;
1638
1639 if (speed_ms[device_id])
1640 {
1641 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1642
1643 hashes_all_ms += hashes_dev_ms[device_id];
1644 }
1645 }
1646
1647 /**
1648 * exec time
1649 */
1650
1651 double exec_all_ms[DEVICES_MAX] = { 0 };
1652
1653 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1654 {
1655 hc_device_param_t *device_param = &data.devices_param[device_id];
1656
1657 if (device_param->skipped) continue;
1658
1659 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1660
1661 exec_all_ms[device_id] = exec_ms_avg;
1662 }
1663
1664 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1665 {
1666 hc_device_param_t *device_param = &data.devices_param[device_id];
1667
1668 if (device_param->skipped) continue;
1669
1670 char display_dev_cur[16] = { 0 };
1671
1672 strncpy (display_dev_cur, "0.00", 4);
1673
1674 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1675
1676 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1677 }
1678
1679 char display_all_cur[16] = { 0 };
1680
1681 strncpy (display_all_cur, "0.00", 4);
1682
1683 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1684
1685 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1686 }
1687
1688 /**
1689 * oclHashcat -only- functions
1690 */
1691
1692 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1693 {
1694 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1695 {
1696 if (attack_kern == ATTACK_KERN_STRAIGHT)
1697 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1698 else if (attack_kern == ATTACK_KERN_COMBI)
1699 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1700 else if (attack_kern == ATTACK_KERN_BF)
1701 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1702 }
1703 else
1704 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1705 }
1706
1707 static void generate_cached_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1708 {
1709 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1710 {
1711 if (attack_kern == ATTACK_KERN_STRAIGHT)
1712 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1713 else if (attack_kern == ATTACK_KERN_COMBI)
1714 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1715 else if (attack_kern == ATTACK_KERN_BF)
1716 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1717 }
1718 else
1719 {
1720 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1721 }
1722 }
1723
1724 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1725 {
1726 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1727 {
1728 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1729 }
1730 else
1731 {
1732 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1733 }
1734 }
1735
1736 static void generate_cached_kernel_mp_filename (const uint opti_type, const uint opts_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1737 {
1738 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1739 {
1740 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1741 }
1742 else
1743 {
1744 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1745 }
1746 }
1747
1748 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1749 {
1750 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1751 }
1752
1753 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1754 {
1755 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1756 }
1757
1758 static uint convert_from_hex (char *line_buf, const uint line_len)
1759 {
1760 if (line_len & 1) return (line_len); // not in hex
1761
1762 if (data.hex_wordlist == 1)
1763 {
1764 uint i;
1765 uint j;
1766
1767 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1768 {
1769 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1770 }
1771
1772 memset (line_buf + i, 0, line_len - i);
1773
1774 return (i);
1775 }
1776 else if (line_len >= 6) // $HEX[] = 6
1777 {
1778 if (line_buf[0] != '$') return (line_len);
1779 if (line_buf[1] != 'H') return (line_len);
1780 if (line_buf[2] != 'E') return (line_len);
1781 if (line_buf[3] != 'X') return (line_len);
1782 if (line_buf[4] != '[') return (line_len);
1783 if (line_buf[line_len - 1] != ']') return (line_len);
1784
1785 uint i;
1786 uint j;
1787
1788 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1789 {
1790 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1791 }
1792
1793 memset (line_buf + i, 0, line_len - i);
1794
1795 return (i);
1796 }
1797
1798 return (line_len);
1799 }
1800
1801 static void clear_prompt ()
1802 {
1803 fputc ('\r', stdout);
1804
1805 for (size_t i = 0; i < strlen (PROMPT); i++)
1806 {
1807 fputc (' ', stdout);
1808 }
1809
1810 fputc ('\r', stdout);
1811
1812 fflush (stdout);
1813 }
1814
1815 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1816 {
1817 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, gidd * sizeof (pw_t), sizeof (pw_t), pw, 0, NULL, NULL);
1818 }
1819
1820 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1821 {
1822 char *outfile = data.outfile;
1823 uint quiet = data.quiet;
1824 FILE *pot_fp = data.pot_fp;
1825 uint loopback = data.loopback;
1826 uint debug_mode = data.debug_mode;
1827 char *debug_file = data.debug_file;
1828
1829 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1830 int debug_rule_len = 0; // -1 error
1831 uint debug_plain_len = 0;
1832
1833 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1834
1835 // hash
1836
1837 char out_buf[HCBUFSIZ] = { 0 };
1838
1839 ascii_digest (out_buf, salt_pos, digest_pos);
1840
1841 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1842
1843 // plain
1844
1845 plain_t plain;
1846
1847 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, idx * sizeof (plain_t), sizeof (plain_t), &plain, 0, NULL, NULL);
1848
1849 uint gidvid = plain.gidvid;
1850 uint il_pos = plain.il_pos;
1851
1852 u64 crackpos = device_param->words_off;
1853
1854 uint plain_buf[16] = { 0 };
1855
1856 u8 *plain_ptr = (u8 *) plain_buf;
1857 unsigned int plain_len = 0;
1858
1859 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1860 {
1861 u64 gidd = gidvid;
1862 u64 gidm = 0;
1863
1864 pw_t pw;
1865
1866 gidd_to_pw_t (device_param, gidd, &pw);
1867
1868 for (int i = 0, j = gidm; i < 16; i++, j++)
1869 {
1870 plain_buf[i] = pw.i[j];
1871 }
1872
1873 plain_len = pw.pw_len;
1874
1875 const uint off = device_param->innerloop_pos + il_pos;
1876
1877 if (debug_mode > 0)
1878 {
1879 debug_rule_len = 0;
1880
1881 // save rule
1882 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1883 {
1884 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1885
1886 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1887 }
1888
1889 // save plain
1890 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1891 {
1892 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1893
1894 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1895
1896 debug_plain_len = plain_len;
1897 }
1898 }
1899
1900 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1901
1902 crackpos += gidvid;
1903 crackpos *= data.kernel_rules_cnt;
1904 crackpos += device_param->innerloop_pos + il_pos;
1905
1906 if (plain_len > data.pw_max) plain_len = data.pw_max;
1907 }
1908 else if (data.attack_mode == ATTACK_MODE_COMBI)
1909 {
1910 u64 gidd = gidvid;
1911 u64 gidm = 0;
1912
1913 pw_t pw;
1914
1915 gidd_to_pw_t (device_param, gidd, &pw);
1916
1917 for (int i = 0, j = gidm; i < 16; i++, j++)
1918 {
1919 plain_buf[i] = pw.i[j];
1920 }
1921
1922 plain_len = pw.pw_len;
1923
1924 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1925 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1926
1927 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1928 {
1929 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1930 }
1931 else
1932 {
1933 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1934
1935 memcpy (plain_ptr, comb_buf, comb_len);
1936 }
1937
1938 plain_len += comb_len;
1939
1940 crackpos += gidvid;
1941 crackpos *= data.combs_cnt;
1942 crackpos += device_param->innerloop_pos + il_pos;
1943
1944 if (data.pw_max != PW_DICTMAX1)
1945 {
1946 if (plain_len > data.pw_max) plain_len = data.pw_max;
1947 }
1948 }
1949 else if (data.attack_mode == ATTACK_MODE_BF)
1950 {
1951 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1952 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1953
1954 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1955 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1956
1957 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1958 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1959
1960 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1961 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1962
1963 plain_len = data.css_cnt;
1964
1965 crackpos += gidvid;
1966 crackpos *= data.bfs_cnt;
1967 crackpos += device_param->innerloop_pos + il_pos;
1968 }
1969 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1970 {
1971 u64 gidd = gidvid;
1972 u64 gidm = 0;
1973
1974 pw_t pw;
1975
1976 gidd_to_pw_t (device_param, gidd, &pw);
1977
1978 for (int i = 0, j = gidm; i < 16; i++, j++)
1979 {
1980 plain_buf[i] = pw.i[j];
1981 }
1982
1983 plain_len = pw.pw_len;
1984
1985 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
1986
1987 uint start = 0;
1988 uint stop = device_param->kernel_params_mp_buf32[4];
1989
1990 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
1991
1992 plain_len += start + stop;
1993
1994 crackpos += gidvid;
1995 crackpos *= data.combs_cnt;
1996 crackpos += device_param->innerloop_pos + il_pos;
1997
1998 if (data.pw_max != PW_DICTMAX1)
1999 {
2000 if (plain_len > data.pw_max) plain_len = data.pw_max;
2001 }
2002 }
2003 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2004 {
2005 u64 gidd = gidvid;
2006 u64 gidm = 0;
2007
2008 pw_t pw;
2009
2010 gidd_to_pw_t (device_param, gidd, &pw);
2011
2012 for (int i = 0, j = gidm; i < 16; i++, j++)
2013 {
2014 plain_buf[i] = pw.i[j];
2015 }
2016
2017 plain_len = pw.pw_len;
2018
2019 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2020
2021 uint start = 0;
2022 uint stop = device_param->kernel_params_mp_buf32[4];
2023
2024 memmove (plain_ptr + stop, plain_ptr, plain_len);
2025
2026 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2027
2028 plain_len += start + stop;
2029
2030 crackpos += gidvid;
2031 crackpos *= data.combs_cnt;
2032 crackpos += device_param->innerloop_pos + il_pos;
2033
2034 if (data.pw_max != PW_DICTMAX1)
2035 {
2036 if (plain_len > data.pw_max) plain_len = data.pw_max;
2037 }
2038 }
2039
2040 if (data.attack_mode == ATTACK_MODE_BF)
2041 {
2042 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2043 {
2044 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2045 {
2046 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2047 {
2048 plain_len = plain_len - data.salts_buf[0].salt_len;
2049 }
2050 }
2051
2052 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2053 {
2054 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2055 {
2056 plain_ptr[j] = plain_ptr[i];
2057 }
2058
2059 plain_len = plain_len / 2;
2060 }
2061 }
2062 }
2063
2064 // if enabled, update also the potfile
2065
2066 if (pot_fp)
2067 {
2068 lock_file (pot_fp);
2069
2070 fprintf (pot_fp, "%s:", out_buf);
2071
2072 format_plain (pot_fp, plain_ptr, plain_len, 1);
2073
2074 fputc ('\n', pot_fp);
2075
2076 fflush (pot_fp);
2077
2078 unlock_file (pot_fp);
2079 }
2080
2081 // outfile
2082
2083 FILE *out_fp = NULL;
2084
2085 if (outfile != NULL)
2086 {
2087 if ((out_fp = fopen (outfile, "ab")) == NULL)
2088 {
2089 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2090
2091 out_fp = stdout;
2092 }
2093 lock_file (out_fp);
2094 }
2095 else
2096 {
2097 out_fp = stdout;
2098
2099 if (quiet == 0) clear_prompt ();
2100 }
2101
2102 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2103
2104 if (outfile != NULL)
2105 {
2106 if (out_fp != stdout)
2107 {
2108 fclose (out_fp);
2109 }
2110 }
2111 else
2112 {
2113 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2114 {
2115 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2116 {
2117 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2118 if (quiet == 0) fflush (stdout);
2119 }
2120 }
2121 }
2122
2123 // loopback
2124
2125 if (loopback)
2126 {
2127 char *loopback_file = data.loopback_file;
2128
2129 FILE *fb_fp = NULL;
2130
2131 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2132 {
2133 lock_file (fb_fp);
2134
2135 format_plain (fb_fp, plain_ptr, plain_len, 1);
2136
2137 fputc ('\n', fb_fp);
2138
2139 fclose (fb_fp);
2140 }
2141 }
2142
2143 // (rule) debug mode
2144
2145 // the next check implies that:
2146 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2147 // - debug_mode > 0
2148
2149 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2150 {
2151 if (debug_rule_len < 0) debug_rule_len = 0;
2152
2153 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2154
2155 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2156
2157 if ((quiet == 0) && (debug_file == NULL))
2158 {
2159 fprintf (stdout, "%s", PROMPT);
2160 fflush (stdout);
2161 }
2162 }
2163 }
2164
2165 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2166 {
2167 salt_t *salt_buf = &data.salts_buf[salt_pos];
2168
2169 int found = 0;
2170
2171 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2172
2173 for (uint i = 0; i < KERNEL_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2174
2175 if (found == 1)
2176 {
2177 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2178
2179 log_info_nn ("");
2180
2181 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL);
2182
2183 uint cpt_cracked = 0;
2184
2185 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2186 {
2187 uint idx = salt_buf->digests_offset + digest_pos;
2188
2189 if (data.digests_shown_tmp[idx] == 0) continue;
2190
2191 if (data.digests_shown[idx] == 1) continue;
2192
2193 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2194 {
2195 data.digests_shown[idx] = 1;
2196
2197 data.digests_done++;
2198
2199 cpt_cracked++;
2200
2201 salt_buf->digests_done++;
2202
2203 if (salt_buf->digests_done == salt_buf->digests_cnt)
2204 {
2205 data.salts_shown[salt_pos] = 1;
2206
2207 data.salts_done++;
2208 }
2209 }
2210
2211 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2212
2213 check_hash (device_param, salt_pos, digest_pos);
2214 }
2215
2216 if (cpt_cracked > 0)
2217 {
2218 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2219 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2220
2221 data.cpt_pos++;
2222
2223 data.cpt_total += cpt_cracked;
2224
2225 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2226 }
2227
2228 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2229 {
2230 // we need to reset cracked state on the device
2231 // otherwise host thinks again and again the hash was cracked
2232 // and returns invalid password each time
2233
2234 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2235
2236 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL);
2237 }
2238
2239 memset (device_param->result, 0, device_param->size_results);
2240
2241 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2242 }
2243 }
2244
2245 static void save_hash ()
2246 {
2247 char *hashfile = data.hashfile;
2248
2249 char new_hashfile[256] = { 0 };
2250 char old_hashfile[256] = { 0 };
2251
2252 snprintf (new_hashfile, 255, "%s.new", hashfile);
2253 snprintf (old_hashfile, 255, "%s.old", hashfile);
2254
2255 unlink (new_hashfile);
2256
2257 char separator = data.separator;
2258
2259 FILE *fp = fopen (new_hashfile, "wb");
2260
2261 if (fp == NULL)
2262 {
2263 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2264
2265 exit (-1);
2266 }
2267
2268 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2269 {
2270 if (data.salts_shown[salt_pos] == 1) continue;
2271
2272 salt_t *salt_buf = &data.salts_buf[salt_pos];
2273
2274 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2275 {
2276 uint idx = salt_buf->digests_offset + digest_pos;
2277
2278 if (data.digests_shown[idx] == 1) continue;
2279
2280 if (data.hash_mode != 2500)
2281 {
2282 char out_buf[HCBUFSIZ] = { 0 };
2283
2284 if (data.username == 1)
2285 {
2286 user_t *user = data.hash_info[idx]->user;
2287
2288 uint i;
2289
2290 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2291
2292 fputc (separator, fp);
2293 }
2294
2295 ascii_digest (out_buf, salt_pos, digest_pos);
2296
2297 fputs (out_buf, fp);
2298
2299 log_out (fp, "");
2300 }
2301 else
2302 {
2303 hccap_t hccap;
2304
2305 to_hccap_t (&hccap, salt_pos, digest_pos);
2306
2307 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2308 }
2309 }
2310 }
2311
2312 fflush (fp);
2313
2314 fclose (fp);
2315
2316 unlink (old_hashfile);
2317
2318 if (rename (hashfile, old_hashfile) != 0)
2319 {
2320 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2321
2322 exit (-1);
2323 }
2324
2325 unlink (hashfile);
2326
2327 if (rename (new_hashfile, hashfile) != 0)
2328 {
2329 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2330
2331 exit (-1);
2332 }
2333
2334 unlink (old_hashfile);
2335 }
2336
2337 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2338 {
2339 // function called only in case kernel_power_all > words_left
2340
2341 float kernel_power_div = (float) (total_left) / kernel_power_all;
2342
2343 kernel_power_div += kernel_power_div / 100;
2344
2345 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2346
2347 while (kernel_power_new < total_left)
2348 {
2349 kernel_power_div += kernel_power_div / 100;
2350
2351 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2352 }
2353
2354 if (data.quiet == 0)
2355 {
2356 clear_prompt ();
2357
2358 log_info ("");
2359
2360 log_info ("INFO: approaching final keyspace, workload adjusted");
2361
2362 log_info ("");
2363
2364 fprintf (stdout, "%s", PROMPT);
2365
2366 fflush (stdout);
2367 }
2368
2369 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2370
2371 return kernel_power_div;
2372 }
2373
2374 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2375 {
2376 uint num_elements = num;
2377
2378 device_param->kernel_params_buf32[30] = data.combs_mode;
2379 device_param->kernel_params_buf32[31] = num;
2380
2381 uint kernel_threads = device_param->kernel_threads;
2382
2383 while (num_elements % kernel_threads) num_elements++;
2384
2385 cl_kernel kernel = NULL;
2386
2387 switch (kern_run)
2388 {
2389 case KERN_RUN_1: kernel = device_param->kernel1; break;
2390 case KERN_RUN_12: kernel = device_param->kernel12; break;
2391 case KERN_RUN_2: kernel = device_param->kernel2; break;
2392 case KERN_RUN_23: kernel = device_param->kernel23; break;
2393 case KERN_RUN_3: kernel = device_param->kernel3; break;
2394 }
2395
2396 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2397 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2398 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2399 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2400 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2401 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2402 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2403 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2404 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2405 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2406 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2407
2408 hc_timer_t timer;
2409
2410 hc_timer_set (&timer);
2411
2412 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2413 {
2414 const size_t global_work_size[3] = { num_elements, 32, 1 };
2415 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2416
2417 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2418 }
2419 else
2420 {
2421 size_t workgroup_size = 0;
2422
2423 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2424
2425 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2426
2427 const size_t global_work_size[3] = { num_elements, 1, 1 };
2428 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2429
2430 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2431 }
2432
2433 hc_clFlush (data.ocl, device_param->command_queue);
2434
2435 hc_clFinish (data.ocl, device_param->command_queue);
2436
2437 if (event_update)
2438 {
2439 double exec_time;
2440
2441 hc_timer_get (timer, exec_time);
2442
2443 uint exec_pos = device_param->exec_pos;
2444
2445 device_param->exec_ms[exec_pos] = exec_time;
2446
2447 exec_pos++;
2448
2449 if (exec_pos == EXEC_CACHE)
2450 {
2451 exec_pos = 0;
2452 }
2453
2454 device_param->exec_pos = exec_pos;
2455 }
2456 }
2457
2458 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2459 {
2460 uint num_elements = num;
2461
2462 switch (kern_run)
2463 {
2464 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2465 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2466 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2467 }
2468
2469 // causes problems with special threads like in bcrypt
2470 // const uint kernel_threads = device_param->kernel_threads;
2471
2472 uint kernel_threads = KERNEL_THREADS;
2473
2474 while (num_elements % kernel_threads) num_elements++;
2475
2476 cl_kernel kernel = NULL;
2477
2478 switch (kern_run)
2479 {
2480 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2481 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2482 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2483 }
2484
2485 switch (kern_run)
2486 {
2487 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2488 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2489 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2490 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2491 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2492 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2493 break;
2494 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2495 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2496 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2497 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2498 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2499 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2500 break;
2501 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2502 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2503 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2504 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2505 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2506 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2507 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2508 break;
2509 }
2510
2511 size_t workgroup_size = 0;
2512 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), &workgroup_size, NULL);
2513 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2514
2515 const size_t global_work_size[3] = { num_elements, 1, 1 };
2516 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2517
2518 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2519
2520 hc_clFlush (data.ocl, device_param->command_queue);
2521
2522 hc_clFinish (data.ocl, device_param->command_queue);
2523 }
2524
2525 static void run_kernel_tm (hc_device_param_t *device_param)
2526 {
2527 const uint num_elements = 1024; // fixed
2528
2529 uint kernel_threads = 32;
2530
2531 cl_kernel kernel = device_param->kernel_tm;
2532
2533 size_t workgroup_size = 0;
2534 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2535 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2536
2537 const size_t global_work_size[3] = { num_elements, 1, 1 };
2538 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2539
2540 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2541
2542 hc_clFlush (data.ocl, device_param->command_queue);
2543
2544 hc_clFinish (data.ocl, device_param->command_queue);
2545 }
2546
2547 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2548 {
2549 uint num_elements = num;
2550
2551 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2552 device_param->kernel_params_amp_buf32[6] = num_elements;
2553
2554 // causes problems with special threads like in bcrypt
2555 // const uint kernel_threads = device_param->kernel_threads;
2556
2557 uint kernel_threads = KERNEL_THREADS;
2558
2559 while (num_elements % kernel_threads) num_elements++;
2560
2561 cl_kernel kernel = device_param->kernel_amp;
2562
2563 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2564 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2565
2566 size_t workgroup_size = 0;
2567 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2568 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2569
2570 const size_t global_work_size[3] = { num_elements, 1, 1 };
2571 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2572
2573 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2574
2575 hc_clFlush (data.ocl, device_param->command_queue);
2576
2577 hc_clFinish (data.ocl, device_param->command_queue);
2578 }
2579
2580 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2581 {
2582 int rc = -1;
2583
2584 if (device_param->opencl_v12 && device_param->vendor_id == VENDOR_ID_AMD)
2585 {
2586 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2587
2588 const cl_uchar zero = 0;
2589
2590 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2591 }
2592
2593 if (rc != 0)
2594 {
2595 // NOTE: clEnqueueFillBuffer () always fails with -59
2596 // IOW, it's not supported by Nvidia ForceWare <= 352.21, also pocl segfaults, also on apple
2597 // How's that possible, OpenCL 1.2 support is advertised??
2598 // We need to workaround...
2599
2600 #define FILLSZ 0x100000
2601
2602 char *tmp = (char *) mymalloc (FILLSZ);
2603
2604 for (uint i = 0; i < size; i += FILLSZ)
2605 {
2606 const int left = size - i;
2607
2608 const int fillsz = MIN (FILLSZ, left);
2609
2610 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2611 }
2612
2613 myfree (tmp);
2614 }
2615 }
2616
2617 static void choose_kernel (hc_device_param_t *device_param, const uint attack_exec, const uint attack_mode, const uint opts_type, const salt_t *salt_buf, const uint highest_pw_len, const uint pws_cnt)
2618 {
2619 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2620 {
2621 if (attack_mode == ATTACK_MODE_BF)
2622 {
2623 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2624 {
2625 const uint size_tm = 32 * sizeof (bs_word_t);
2626
2627 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2628
2629 run_kernel_tm (device_param);
2630
2631 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_tm_c, device_param->d_bfs_c, 0, 0, size_tm, 0, NULL, NULL);
2632 }
2633 }
2634
2635 if (highest_pw_len < 16)
2636 {
2637 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2638 }
2639 else if (highest_pw_len < 32)
2640 {
2641 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2642 }
2643 else
2644 {
2645 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2646 }
2647 }
2648 else
2649 {
2650 run_kernel_amp (device_param, pws_cnt);
2651
2652 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2653
2654 if (opts_type & OPTS_TYPE_HOOK12)
2655 {
2656 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2657 }
2658
2659 uint iter = salt_buf->salt_iter;
2660
2661 uint loop_step = device_param->kernel_loops;
2662
2663 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2664 {
2665 uint loop_left = iter - loop_pos;
2666
2667 loop_left = MIN (loop_left, loop_step);
2668
2669 device_param->kernel_params_buf32[25] = loop_pos;
2670 device_param->kernel_params_buf32[26] = loop_left;
2671
2672 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2673
2674 if (data.devices_status == STATUS_CRACKED) break;
2675 if (data.devices_status == STATUS_ABORTED) break;
2676 if (data.devices_status == STATUS_QUIT) break;
2677
2678 /**
2679 * speed
2680 */
2681
2682 const float iter_part = (float) (loop_pos + loop_left) / iter;
2683
2684 const u64 perf_sum_all = pws_cnt * iter_part;
2685
2686 double speed_ms;
2687
2688 hc_timer_get (device_param->timer_speed, speed_ms);
2689
2690 const u32 speed_pos = device_param->speed_pos;
2691
2692 device_param->speed_cnt[speed_pos] = perf_sum_all;
2693
2694 device_param->speed_ms[speed_pos] = speed_ms;
2695 }
2696
2697 if (opts_type & OPTS_TYPE_HOOK23)
2698 {
2699 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2700
2701 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2702
2703 // do something with data
2704
2705 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2706 }
2707
2708 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2709 }
2710 }
2711
2712 static int run_rule_engine (const int rule_len, const char *rule_buf)
2713 {
2714 if (rule_len == 0)
2715 {
2716 return 0;
2717 }
2718 else if (rule_len == 1)
2719 {
2720 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2721 }
2722
2723 return 1;
2724 }
2725
2726 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2727 {
2728 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2729 {
2730 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2731 }
2732 else if (data.attack_kern == ATTACK_KERN_COMBI)
2733 {
2734 if (data.attack_mode == ATTACK_MODE_HYBRID2)
2735 {
2736 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2737 {
2738 for (u32 i = 0; i < pws_cnt; i++)
2739 {
2740 const u32 pw_len = device_param->pws_buf[i].pw_len;
2741
2742 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2743
2744 ptr[pw_len] = 0x01;
2745 }
2746 }
2747 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2748 {
2749 for (u32 i = 0; i < pws_cnt; i++)
2750 {
2751 const u32 pw_len = device_param->pws_buf[i].pw_len;
2752
2753 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2754
2755 ptr[pw_len] = 0x80;
2756 }
2757 }
2758 }
2759
2760 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2761 }
2762 else if (data.attack_kern == ATTACK_KERN_BF)
2763 {
2764 const u64 off = device_param->words_off;
2765
2766 device_param->kernel_params_mp_l_buf64[3] = off;
2767
2768 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2769 }
2770 }
2771
2772 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops, const int repeat)
2773 {
2774 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2775
2776 device_param->kernel_params_buf32[26] = kernel_loops;
2777 device_param->kernel_params_buf32[27] = kernel_loops;
2778
2779 // init some fake words
2780
2781 for (u32 i = 0; i < kernel_power; i++)
2782 {
2783 device_param->pws_buf[i].i[0] = i;
2784 device_param->pws_buf[i].i[1] = 0x01234567;
2785 device_param->pws_buf[i].pw_len = 4 + (i & 3);
2786 }
2787
2788 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, kernel_power * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2789
2790 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2791 {
2792 run_kernel_amp (device_param, kernel_power);
2793 }
2794
2795 // caching run
2796
2797 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2798 {
2799 run_kernel (KERN_RUN_1, device_param, kernel_power, false);
2800 }
2801 else
2802 {
2803 run_kernel (KERN_RUN_2, device_param, kernel_power, false);
2804 }
2805
2806 // now user repeats
2807
2808 for (int i = 0; i < repeat; i++)
2809 {
2810 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2811 {
2812 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2813 }
2814 else
2815 {
2816 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2817 }
2818 }
2819
2820 const double exec_ms_prev = get_avg_exec_time (device_param, repeat);
2821
2822 // reset fake words
2823
2824 memset (device_param->pws_buf, 0, kernel_power * sizeof (pw_t));
2825
2826 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, kernel_power * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2827 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_amp_buf, CL_TRUE, 0, kernel_power * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2828
2829 return exec_ms_prev;
2830 }
2831
2832 static void autotune (hc_device_param_t *device_param)
2833 {
2834 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2835
2836 const u32 kernel_accel_min = device_param->kernel_accel_min;
2837 const u32 kernel_accel_max = device_param->kernel_accel_max;
2838
2839 const u32 kernel_loops_min = device_param->kernel_loops_min;
2840 const u32 kernel_loops_max = device_param->kernel_loops_max;
2841
2842 u32 kernel_accel = kernel_accel_min;
2843 u32 kernel_loops = kernel_loops_min;
2844
2845 // steps
2846
2847 #define STEPS_CNT 10
2848
2849 #define STEPS_ACCEL_CNT (STEPS_CNT + 2)
2850 #define STEPS_LOOPS_CNT (STEPS_CNT + 2)
2851
2852 u32 steps_accel[STEPS_ACCEL_CNT];
2853 u32 steps_loops[STEPS_LOOPS_CNT];
2854
2855 for (int i = 0; i < STEPS_ACCEL_CNT; i++)
2856 {
2857 steps_accel[i] = 1 << i;
2858 }
2859
2860 for (int i = 0; i < STEPS_LOOPS_CNT; i++)
2861 {
2862 steps_loops[i] = 1 << i;
2863 }
2864
2865 steps_accel[STEPS_CNT + 0] = kernel_accel_min;
2866 steps_accel[STEPS_CNT + 1] = kernel_accel_max;
2867
2868 steps_loops[STEPS_CNT + 0] = kernel_loops_min;
2869 steps_loops[STEPS_CNT + 1] = kernel_loops_max;
2870
2871 qsort (steps_accel, STEPS_ACCEL_CNT, sizeof (u32), sort_by_u32);
2872 qsort (steps_loops, STEPS_LOOPS_CNT, sizeof (u32), sort_by_u32);
2873
2874 // find out highest kernel-loops that stays below target_ms, we can use it later for multiplication as this is a linear function
2875
2876 u32 kernel_loops_tmp;
2877
2878 for (kernel_loops_tmp = kernel_loops_max; kernel_loops_tmp > kernel_loops_min; kernel_loops_tmp >>= 1)
2879 {
2880 const double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops_tmp, 1);
2881
2882 if (exec_ms < target_ms) break;
2883 }
2884
2885 // kernel-accel
2886
2887 if (kernel_accel_min < kernel_accel_max)
2888 {
2889 double e_best = 0;
2890
2891 for (int i = 0; i < STEPS_ACCEL_CNT; i++)
2892 {
2893 const u32 kernel_accel_try = steps_accel[i];
2894
2895 if (kernel_accel_try < kernel_accel_min) continue;
2896 if (kernel_accel_try > kernel_accel_max) break;
2897
2898 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_tmp, 1);
2899
2900 if (exec_ms > target_ms) break;
2901
2902 const double e = kernel_accel_try / exec_ms;
2903
2904 if (e > e_best)
2905 {
2906 kernel_accel = kernel_accel_try;
2907
2908 e_best = e;
2909 }
2910 }
2911 }
2912
2913 // kernel-loops final
2914
2915 if (kernel_loops_min < kernel_loops_max)
2916 {
2917 double e_best = 0;
2918
2919 for (int i = 0; i < STEPS_LOOPS_CNT; i++)
2920 {
2921 const u32 kernel_loops_try = steps_loops[i];
2922
2923 if (kernel_loops_try < kernel_loops_min) continue;
2924 if (kernel_loops_try > kernel_loops_max) break;
2925
2926 const double exec_ms = try_run (device_param, kernel_accel, kernel_loops_try, 1);
2927
2928 if (exec_ms > target_ms) break;
2929
2930 const double e = kernel_loops_try / exec_ms;
2931
2932 if (e > e_best)
2933 {
2934 kernel_loops = kernel_loops_try;
2935
2936 e_best = e;
2937 }
2938 }
2939 }
2940
2941 // final balance
2942
2943 u32 kernel_accel_best = kernel_accel;
2944 u32 kernel_loops_best = kernel_loops;
2945
2946 u32 exec_best = -1;
2947
2948 if ((kernel_accel_min < kernel_accel_max) || (kernel_loops_min < kernel_loops_max))
2949 {
2950 const double exec_ms = try_run (device_param, kernel_accel_best, kernel_loops_best, 1);
2951
2952 exec_best = exec_ms;
2953 }
2954
2955 // reset
2956
2957 if (kernel_accel_min < kernel_accel_max)
2958 {
2959 u32 kernel_accel_try = kernel_accel;
2960 u32 kernel_loops_try = kernel_loops;
2961
2962 for (int i = 0; i < 2; i++)
2963 {
2964 kernel_accel_try >>= 1;
2965 kernel_loops_try <<= 1;
2966
2967 if (kernel_accel_try < kernel_accel_min) break;
2968 if (kernel_loops_try > kernel_loops_max) break;
2969
2970 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
2971
2972 if (exec_ms < exec_best)
2973 {
2974 kernel_accel_best = kernel_accel_try;
2975 kernel_loops_best = kernel_loops_try;
2976
2977 exec_best = exec_ms;
2978 }
2979 }
2980 }
2981
2982 // reset
2983
2984 if (kernel_loops_min < kernel_loops_max)
2985 {
2986 u32 kernel_accel_try = kernel_accel;
2987 u32 kernel_loops_try = kernel_loops;
2988
2989 for (int i = 0; i < 2; i++)
2990 {
2991 kernel_accel_try <<= 1;
2992 kernel_loops_try >>= 1;
2993
2994 if (kernel_accel_try > kernel_accel_max) break;
2995 if (kernel_loops_try < kernel_loops_min) break;
2996
2997 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
2998
2999 if (exec_ms < exec_best)
3000 {
3001 kernel_accel_best = kernel_accel_try;
3002 kernel_loops_best = kernel_loops_try;
3003
3004 exec_best = exec_ms;
3005 }
3006 }
3007 }
3008
3009 // reset timer
3010
3011 device_param->exec_pos = 0;
3012
3013 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3014
3015 // store
3016
3017 kernel_accel = kernel_accel_best;
3018 kernel_loops = kernel_loops_best;
3019
3020 device_param->kernel_accel = kernel_accel;
3021 device_param->kernel_loops = kernel_loops;
3022
3023 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3024
3025 device_param->kernel_power = kernel_power;
3026
3027 #ifdef DEBUG
3028
3029 if (data.quiet == 0)
3030 {
3031 clear_prompt ();
3032
3033 log_info ("Device #%u: autotuned kernel-accel to %u\n"
3034 "Device #%u: autotuned kernel-loops to %u\n",
3035 device_param->device_id + 1,
3036 kernel_accel,
3037 device_param->device_id + 1,
3038 kernel_loops);
3039
3040 fprintf (stdout, "%s", PROMPT);
3041 fflush (stdout);
3042 }
3043
3044 #endif
3045 }
3046
3047 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3048 {
3049 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3050
3051 // init speed timer
3052
3053 uint speed_pos = device_param->speed_pos;
3054
3055 #ifdef _POSIX
3056 if (device_param->timer_speed.tv_sec == 0)
3057 {
3058 hc_timer_set (&device_param->timer_speed);
3059 }
3060 #endif
3061
3062 #ifdef _WIN
3063 if (device_param->timer_speed.QuadPart == 0)
3064 {
3065 hc_timer_set (&device_param->timer_speed);
3066 }
3067 #endif
3068
3069 // find higest password length, this is for optimization stuff
3070
3071 uint highest_pw_len = 0;
3072
3073 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3074 {
3075 }
3076 else if (data.attack_kern == ATTACK_KERN_COMBI)
3077 {
3078 }
3079 else if (data.attack_kern == ATTACK_KERN_BF)
3080 {
3081 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3082 + device_param->kernel_params_mp_l_buf32[5];
3083 }
3084
3085 // iteration type
3086
3087 uint innerloop_step = 0;
3088 uint innerloop_cnt = 0;
3089
3090 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3091 else innerloop_step = 1;
3092
3093 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3094 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3095 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3096
3097 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3098
3099 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3100 {
3101 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3102
3103 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3104
3105 if (data.devices_status == STATUS_CRACKED) break;
3106 if (data.devices_status == STATUS_ABORTED) break;
3107 if (data.devices_status == STATUS_QUIT) break;
3108 if (data.devices_status == STATUS_BYPASS) break;
3109
3110 salt_t *salt_buf = &data.salts_buf[salt_pos];
3111
3112 device_param->kernel_params_buf32[24] = salt_pos;
3113 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3114 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3115
3116 FILE *combs_fp = device_param->combs_fp;
3117
3118 if (data.attack_mode == ATTACK_MODE_COMBI)
3119 {
3120 rewind (combs_fp);
3121 }
3122
3123 // innerloops
3124
3125 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3126 {
3127 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3128
3129 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3130
3131 if (data.devices_status == STATUS_CRACKED) break;
3132 if (data.devices_status == STATUS_ABORTED) break;
3133 if (data.devices_status == STATUS_QUIT) break;
3134 if (data.devices_status == STATUS_BYPASS) break;
3135
3136 uint innerloop_left = innerloop_cnt - innerloop_pos;
3137
3138 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3139
3140 device_param->innerloop_pos = innerloop_pos;
3141 device_param->innerloop_left = innerloop_left;
3142
3143 device_param->kernel_params_buf32[27] = innerloop_left;
3144
3145 // i think we can get rid of this
3146 if (innerloop_left == 0)
3147 {
3148 puts ("bug, how should this happen????\n");
3149
3150 continue;
3151 }
3152
3153 if (data.salts_shown[salt_pos] == 1)
3154 {
3155 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3156
3157 continue;
3158 }
3159
3160 // initialize amplifiers
3161
3162 if (data.attack_mode == ATTACK_MODE_COMBI)
3163 {
3164 uint i = 0;
3165
3166 while (i < innerloop_left)
3167 {
3168 if (feof (combs_fp)) break;
3169
3170 int line_len = fgetl (combs_fp, line_buf);
3171
3172 if (line_len >= PW_MAX1) continue;
3173
3174 line_len = convert_from_hex (line_buf, line_len);
3175
3176 char *line_buf_new = line_buf;
3177
3178 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3179 {
3180 char rule_buf_out[BLOCK_SIZE] = { 0 };
3181
3182 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3183
3184 if (rule_len_out < 0)
3185 {
3186 data.words_progress_rejected[salt_pos] += pws_cnt;
3187
3188 continue;
3189 }
3190
3191 line_len = rule_len_out;
3192
3193 line_buf_new = rule_buf_out;
3194 }
3195
3196 line_len = MIN (line_len, PW_DICTMAX);
3197
3198 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3199
3200 memcpy (ptr, line_buf_new, line_len);
3201
3202 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3203
3204 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3205 {
3206 uppercase (ptr, line_len);
3207 }
3208
3209 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3210 {
3211 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3212 {
3213 ptr[line_len] = 0x80;
3214 }
3215
3216 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3217 {
3218 ptr[line_len] = 0x01;
3219 }
3220 }
3221
3222 device_param->combs_buf[i].pw_len = line_len;
3223
3224 i++;
3225 }
3226
3227 for (uint j = i; j < innerloop_left; j++)
3228 {
3229 device_param->combs_buf[j].i[0] = 0;
3230 device_param->combs_buf[j].i[1] = 0;
3231 device_param->combs_buf[j].i[2] = 0;
3232 device_param->combs_buf[j].i[3] = 0;
3233 device_param->combs_buf[j].i[4] = 0;
3234 device_param->combs_buf[j].i[5] = 0;
3235 device_param->combs_buf[j].i[6] = 0;
3236 device_param->combs_buf[j].i[7] = 0;
3237
3238 device_param->combs_buf[j].pw_len = 0;
3239 }
3240
3241 innerloop_left = i;
3242 }
3243 else if (data.attack_mode == ATTACK_MODE_BF)
3244 {
3245 u64 off = innerloop_pos;
3246
3247 device_param->kernel_params_mp_r_buf64[3] = off;
3248
3249 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3250 }
3251 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3252 {
3253 u64 off = innerloop_pos;
3254
3255 device_param->kernel_params_mp_buf64[3] = off;
3256
3257 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3258 }
3259 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3260 {
3261 u64 off = innerloop_pos;
3262
3263 device_param->kernel_params_mp_buf64[3] = off;
3264
3265 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3266 }
3267
3268 // copy amplifiers
3269
3270 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3271 {
3272 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_rules, device_param->d_rules_c, innerloop_pos * sizeof (kernel_rule_t), 0, innerloop_left * sizeof (kernel_rule_t), 0, NULL, NULL);
3273 }
3274 else if (data.attack_mode == ATTACK_MODE_COMBI)
3275 {
3276 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_combs_c, CL_TRUE, 0, innerloop_left * sizeof (comb_t), device_param->combs_buf, 0, NULL, NULL);
3277 }
3278 else if (data.attack_mode == ATTACK_MODE_BF)
3279 {
3280 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_bfs, device_param->d_bfs_c, 0, 0, innerloop_left * sizeof (bf_t), 0, NULL, NULL);
3281 }
3282 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3283 {
3284 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
3285 }
3286 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3287 {
3288 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
3289 }
3290
3291 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3292
3293 if (data.benchmark == 1)
3294 {
3295 double exec_ms_avg_prev = get_avg_exec_time (device_param, EXEC_CACHE);
3296
3297 // a few caching rounds
3298
3299 for (u32 i = 0; i < 2; i++)
3300 {
3301 hc_timer_set (&device_param->timer_speed);
3302
3303 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3304
3305 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
3306
3307 exec_ms_avg_prev = exec_ms_avg;
3308 }
3309
3310 // benchmark_repeats became a maximum possible repeats
3311
3312 for (u32 i = 2; i < data.benchmark_repeats; i++)
3313 {
3314 hc_timer_set (&device_param->timer_speed);
3315
3316 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3317
3318 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
3319
3320 if ((exec_ms_avg_prev / exec_ms_avg) < 1.001) break;
3321
3322 exec_ms_avg_prev = exec_ms_avg;
3323 }
3324 }
3325
3326 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3327
3328 if (data.devices_status == STATUS_CRACKED) break;
3329 if (data.devices_status == STATUS_ABORTED) break;
3330 if (data.devices_status == STATUS_QUIT) break;
3331
3332 /**
3333 * result
3334 */
3335
3336 hc_thread_mutex_lock (mux_display);
3337
3338 check_cracked (device_param, salt_pos);
3339
3340 hc_thread_mutex_unlock (mux_display);
3341
3342 /**
3343 * progress
3344 */
3345
3346 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3347
3348 hc_thread_mutex_lock (mux_counter);
3349
3350 data.words_progress_done[salt_pos] += perf_sum_all;
3351
3352 hc_thread_mutex_unlock (mux_counter);
3353
3354 /**
3355 * speed
3356 */
3357
3358 double speed_ms;
3359
3360 hc_timer_get (device_param->timer_speed, speed_ms);
3361
3362 hc_timer_set (&device_param->timer_speed);
3363
3364 hc_thread_mutex_lock (mux_display);
3365
3366 // current speed
3367
3368 device_param->speed_cnt[speed_pos] = perf_sum_all;
3369
3370 device_param->speed_ms[speed_pos] = speed_ms;
3371
3372 hc_thread_mutex_unlock (mux_display);
3373
3374 speed_pos++;
3375
3376 if (speed_pos == SPEED_CACHE)
3377 {
3378 speed_pos = 0;
3379 }
3380
3381 /**
3382 * benchmark
3383 */
3384
3385 if (data.benchmark == 1) break;
3386 }
3387 }
3388
3389 device_param->speed_pos = speed_pos;
3390
3391 myfree (line_buf);
3392 }
3393
3394 static void load_segment (wl_data_t *wl_data, FILE *fd)
3395 {
3396 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3397
3398 wl_data->pos = 0;
3399
3400 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3401
3402 wl_data->buf[wl_data->cnt] = 0;
3403
3404 if (wl_data->cnt == 0) return;
3405
3406 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3407
3408 while (!feof (fd))
3409 {
3410 if (wl_data->cnt == wl_data->avail)
3411 {
3412 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3413
3414 wl_data->avail += wl_data->incr;
3415 }
3416
3417 const int c = fgetc (fd);
3418
3419 if (c == EOF) break;
3420
3421 wl_data->buf[wl_data->cnt] = (char) c;
3422
3423 wl_data->cnt++;
3424
3425 if (c == '\n') break;
3426 }
3427
3428 // ensure stream ends with a newline
3429
3430 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3431 {
3432 wl_data->cnt++;
3433
3434 wl_data->buf[wl_data->cnt - 1] = '\n';
3435 }
3436
3437 return;
3438 }
3439
3440 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3441 {
3442 char *ptr = buf;
3443
3444 for (u32 i = 0; i < sz; i++, ptr++)
3445 {
3446 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3447
3448 if (i == 7)
3449 {
3450 *off = i;
3451 *len = i;
3452
3453 return;
3454 }
3455
3456 if (*ptr != '\n') continue;
3457
3458 *off = i + 1;
3459
3460 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3461
3462 *len = i;
3463
3464 return;
3465 }
3466
3467 *off = sz;
3468 *len = sz;
3469 }
3470
3471 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3472 {
3473 char *ptr = buf;
3474
3475 for (u32 i = 0; i < sz; i++, ptr++)
3476 {
3477 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3478
3479 if (*ptr != '\n') continue;
3480
3481 *off = i + 1;
3482
3483 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3484
3485 *len = i;
3486
3487 return;
3488 }
3489
3490 *off = sz;
3491 *len = sz;
3492 }
3493
3494 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3495 {
3496 char *ptr = buf;
3497
3498 for (u32 i = 0; i < sz; i++, ptr++)
3499 {
3500 if (*ptr != '\n') continue;
3501
3502 *off = i + 1;
3503
3504 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3505
3506 *len = i;
3507
3508 return;
3509 }
3510
3511 *off = sz;
3512 *len = sz;
3513 }
3514
3515 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3516 {
3517 while (wl_data->pos < wl_data->cnt)
3518 {
3519 uint off;
3520 uint len;
3521
3522 char *ptr = wl_data->buf + wl_data->pos;
3523
3524 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3525
3526 wl_data->pos += off;
3527
3528 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3529 {
3530 char rule_buf_out[BLOCK_SIZE] = { 0 };
3531
3532 int rule_len_out = -1;
3533
3534 if (len < BLOCK_SIZE)
3535 {
3536 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3537 }
3538
3539 if (rule_len_out < 0)
3540 {
3541 continue;
3542 }
3543
3544 if (rule_len_out > PW_MAX)
3545 {
3546 continue;
3547 }
3548 }
3549 else
3550 {
3551 if (len > PW_MAX)
3552 {
3553 continue;
3554 }
3555 }
3556
3557 *out_buf = ptr;
3558 *out_len = len;
3559
3560 return;
3561 }
3562
3563 if (feof (fd))
3564 {
3565 fprintf (stderr, "BUG feof()!!\n");
3566
3567 return;
3568 }
3569
3570 load_segment (wl_data, fd);
3571
3572 get_next_word (wl_data, fd, out_buf, out_len);
3573 }
3574
3575 #ifdef _POSIX
3576 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3577 #endif
3578
3579 #ifdef _WIN
3580 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3581 #endif
3582 {
3583 hc_signal (NULL);
3584
3585 dictstat_t d;
3586
3587 d.cnt = 0;
3588
3589 #ifdef _POSIX
3590 fstat (fileno (fd), &d.stat);
3591 #endif
3592
3593 #ifdef _WIN
3594 _fstat64 (fileno (fd), &d.stat);
3595 #endif
3596
3597 d.stat.st_mode = 0;
3598 d.stat.st_nlink = 0;
3599 d.stat.st_uid = 0;
3600 d.stat.st_gid = 0;
3601 d.stat.st_rdev = 0;
3602 d.stat.st_atime = 0;
3603
3604 #ifdef _POSIX
3605 d.stat.st_blksize = 0;
3606 d.stat.st_blocks = 0;
3607 #endif
3608
3609 if (d.stat.st_size == 0) return 0;
3610
3611 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3612
3613 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3614 {
3615 if (d_cache)
3616 {
3617 u64 cnt = d_cache->cnt;
3618
3619 u64 keyspace = cnt;
3620
3621 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3622 {
3623 keyspace *= data.kernel_rules_cnt;
3624 }
3625 else if (data.attack_kern == ATTACK_KERN_COMBI)
3626 {
3627 keyspace *= data.combs_cnt;
3628 }
3629
3630 if (data.quiet == 0) log_info ("Cache-hit dictionary stats %s: %llu bytes, %llu words, %llu keyspace", dictfile, (unsigned long long int) d.stat.st_size, (unsigned long long int) cnt, (unsigned long long int) keyspace);
3631 if (data.quiet == 0) log_info ("");
3632
3633 hc_signal (sigHandler_default);
3634
3635 return (keyspace);
3636 }
3637 }
3638
3639 time_t now = 0;
3640 time_t prev = 0;
3641
3642 u64 comp = 0;
3643 u64 cnt = 0;
3644 u64 cnt2 = 0;
3645
3646 while (!feof (fd))
3647 {
3648 load_segment (wl_data, fd);
3649
3650 comp += wl_data->cnt;
3651
3652 u32 i = 0;
3653
3654 while (i < wl_data->cnt)
3655 {
3656 u32 len;
3657 u32 off;
3658
3659 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3660
3661 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3662 {
3663 char rule_buf_out[BLOCK_SIZE] = { 0 };
3664
3665 int rule_len_out = -1;
3666
3667 if (len < BLOCK_SIZE)
3668 {
3669 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3670 }
3671
3672 if (rule_len_out < 0)
3673 {
3674 len = PW_MAX1;
3675 }
3676 else
3677 {
3678 len = rule_len_out;
3679 }
3680 }
3681
3682 if (len < PW_MAX1)
3683 {
3684 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3685 {
3686 cnt += data.kernel_rules_cnt;
3687 }
3688 else if (data.attack_kern == ATTACK_KERN_COMBI)
3689 {
3690 cnt += data.combs_cnt;
3691 }
3692
3693 d.cnt++;
3694 }
3695
3696 i += off;
3697
3698 cnt2++;
3699 }
3700
3701 time (&now);
3702
3703 if ((now - prev) == 0) continue;
3704
3705 float percent = (float) comp / (float) d.stat.st_size;
3706
3707 if (data.quiet == 0) log_info_nn ("Generating dictionary stats for %s: %llu bytes (%.2f%%), %llu words, %llu keyspace", dictfile, (unsigned long long int) comp, percent * 100, (unsigned long long int) cnt2, (unsigned long long int) cnt);
3708
3709 time (&prev);
3710 }
3711
3712 if (data.quiet == 0) log_info ("Generated dictionary stats for %s: %llu bytes, %llu words, %llu keyspace", dictfile, (unsigned long long int) comp, (unsigned long long int) cnt2, (unsigned long long int) cnt);
3713 if (data.quiet == 0) log_info ("");
3714
3715 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3716
3717 hc_signal (sigHandler_default);
3718
3719 return (cnt);
3720 }
3721
3722 static void *thread_monitor (void *p)
3723 {
3724 uint runtime_check = 0;
3725 uint remove_check = 0;
3726 uint status_check = 0;
3727 uint restore_check = 0;
3728
3729 uint restore_left = data.restore_timer;
3730 uint remove_left = data.remove_timer;
3731 uint status_left = data.status_timer;
3732
3733 #ifdef HAVE_HWMON
3734 uint hwmon_check = 0;
3735
3736 // these variables are mainly used for fan control (AMD only)
3737
3738 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3739
3740 // temperature controller "loopback" values
3741
3742 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3743 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3744
3745 #ifdef HAVE_ADL
3746 int temp_threshold = 1; // degrees celcius
3747
3748 int fan_speed_min = 15; // in percentage
3749 int fan_speed_max = 100;
3750 #endif // HAVE_ADL
3751
3752 time_t last_temp_check_time;
3753 #endif // HAVE_HWMON
3754
3755 uint sleep_time = 1;
3756
3757 if (data.runtime)
3758 {
3759 runtime_check = 1;
3760 }
3761
3762 if (data.restore_timer)
3763 {
3764 restore_check = 1;
3765 }
3766
3767 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3768 {
3769 remove_check = 1;
3770 }
3771
3772 if (data.status == 1)
3773 {
3774 status_check = 1;
3775 }
3776
3777 #ifdef HAVE_HWMON
3778 if (data.gpu_temp_disable == 0)
3779 {
3780 time (&last_temp_check_time);
3781
3782 hwmon_check = 1;
3783 }
3784 #endif
3785
3786 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3787 {
3788 #ifdef HAVE_HWMON
3789 if (hwmon_check == 0)
3790 #endif
3791 return (p);
3792 }
3793
3794 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3795 {
3796 hc_sleep (sleep_time);
3797
3798 if (data.devices_status != STATUS_RUNNING) continue;
3799
3800 #ifdef HAVE_HWMON
3801 if (hwmon_check == 1)
3802 {
3803 hc_thread_mutex_lock (mux_adl);
3804
3805 time_t temp_check_time;
3806
3807 time (&temp_check_time);
3808
3809 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3810
3811 if (Ta == 0) Ta = 1;
3812
3813 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3814 {
3815 hc_device_param_t *device_param = &data.devices_param[device_id];
3816
3817 if (device_param->skipped) continue;
3818
3819 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3820
3821 const int temperature = hm_get_temperature_with_device_id (device_id);
3822
3823 if (temperature > (int) data.gpu_temp_abort)
3824 {
3825 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3826
3827 if (data.devices_status != STATUS_QUIT) myabort ();
3828
3829 break;
3830 }
3831
3832 #ifdef HAVE_ADL
3833 const int gpu_temp_retain = data.gpu_temp_retain;
3834
3835 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3836 {
3837 if (data.hm_device[device_id].fan_supported == 1)
3838 {
3839 int temp_cur = temperature;
3840
3841 int temp_diff_new = gpu_temp_retain - temp_cur;
3842
3843 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3844
3845 // calculate Ta value (time difference in seconds between the last check and this check)
3846
3847 last_temp_check_time = temp_check_time;
3848
3849 float Kp = 1.8;
3850 float Ki = 0.005;
3851 float Kd = 6;
3852
3853 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3854
3855 int fan_diff_required = (int) (Kp * (float)temp_diff_new + Ki * Ta * (float)temp_diff_sum[device_id] + Kd * ((float)(temp_diff_new - temp_diff_old[device_id])) / Ta);
3856
3857 if (abs (fan_diff_required) >= temp_threshold)
3858 {
3859 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3860
3861 int fan_speed_level = fan_speed_cur;
3862
3863 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3864
3865 int fan_speed_new = fan_speed_level - fan_diff_required;
3866
3867 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3868 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3869
3870 if (fan_speed_new != fan_speed_cur)
3871 {
3872 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3873 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3874
3875 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3876 {
3877 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3878
3879 fan_speed_chgd[device_id] = 1;
3880 }
3881
3882 temp_diff_old[device_id] = temp_diff_new;
3883 }
3884 }
3885 }
3886 }
3887 #endif // HAVE_ADL
3888 }
3889
3890 hc_thread_mutex_unlock (mux_adl);
3891 }
3892 #endif // HAVE_HWMON
3893
3894 if (restore_check == 1)
3895 {
3896 restore_left--;
3897
3898 if (restore_left == 0)
3899 {
3900 if (data.restore_disable == 0) cycle_restore ();
3901
3902 restore_left = data.restore_timer;
3903 }
3904 }
3905
3906 if ((runtime_check == 1) && (data.runtime_start > 0))
3907 {
3908 time_t runtime_cur;
3909
3910 time (&runtime_cur);
3911
3912 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3913
3914 if (runtime_left <= 0)
3915 {
3916 if (data.benchmark == 0)
3917 {
3918 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3919 }
3920
3921 if (data.devices_status != STATUS_QUIT) myabort ();
3922 }
3923 }
3924
3925 if (remove_check == 1)
3926 {
3927 remove_left--;
3928
3929 if (remove_left == 0)
3930 {
3931 if (data.digests_saved != data.digests_done)
3932 {
3933 data.digests_saved = data.digests_done;
3934
3935 save_hash ();
3936 }
3937
3938 remove_left = data.remove_timer;
3939 }
3940 }
3941
3942 if (status_check == 1)
3943 {
3944 status_left--;
3945
3946 if (status_left == 0)
3947 {
3948 hc_thread_mutex_lock (mux_display);
3949
3950 if (data.quiet == 0) clear_prompt ();
3951
3952 if (data.quiet == 0) log_info ("");
3953
3954 status_display ();
3955
3956 if (data.quiet == 0) log_info ("");
3957
3958 hc_thread_mutex_unlock (mux_display);
3959
3960 status_left = data.status_timer;
3961 }
3962 }
3963 }
3964
3965 #ifdef HAVE_HWMON
3966 myfree (fan_speed_chgd);
3967
3968 myfree (temp_diff_old);
3969 myfree (temp_diff_sum);
3970 #endif
3971
3972 p = NULL;
3973
3974 return (p);
3975 }
3976
3977 static void *thread_outfile_remove (void *p)
3978 {
3979 // some hash-dependent constants
3980 char *outfile_dir = data.outfile_check_directory;
3981 uint dgst_size = data.dgst_size;
3982 uint isSalted = data.isSalted;
3983 uint esalt_size = data.esalt_size;
3984 uint hash_mode = data.hash_mode;
3985
3986 uint outfile_check_timer = data.outfile_check_timer;
3987
3988 char separator = data.separator;
3989
3990 // some hash-dependent functions
3991 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3992 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3993
3994 // buffers
3995 hash_t hash_buf = { 0, 0, 0, 0, 0 };
3996
3997 hash_buf.digest = mymalloc (dgst_size);
3998
3999 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4000
4001 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4002
4003 uint digest_buf[64] = { 0 };
4004
4005 outfile_data_t *out_info = NULL;
4006
4007 char **out_files = NULL;
4008
4009 time_t folder_mtime = 0;
4010
4011 int out_cnt = 0;
4012
4013 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4014
4015 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4016 {
4017 hc_sleep (1);
4018
4019 if (data.devices_status != STATUS_RUNNING) continue;
4020
4021 check_left--;
4022
4023 if (check_left == 0)
4024 {
4025 struct stat outfile_check_stat;
4026
4027 if (stat (outfile_dir, &outfile_check_stat) == 0)
4028 {
4029 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4030
4031 if (is_dir == 1)
4032 {
4033 if (outfile_check_stat.st_mtime > folder_mtime)
4034 {
4035 char **out_files_new = scan_directory (outfile_dir);
4036
4037 int out_cnt_new = count_dictionaries (out_files_new);
4038
4039 outfile_data_t *out_info_new = NULL;
4040
4041 if (out_cnt_new > 0)
4042 {
4043 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4044
4045 for (int i = 0; i < out_cnt_new; i++)
4046 {
4047 out_info_new[i].file_name = out_files_new[i];
4048
4049 // check if there are files that we have seen/checked before (and not changed)
4050
4051 for (int j = 0; j < out_cnt; j++)
4052 {
4053 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4054 {
4055 struct stat outfile_stat;
4056
4057 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4058 {
4059 if (outfile_stat.st_ctime == out_info[j].ctime)
4060 {
4061 out_info_new[i].ctime = out_info[j].ctime;
4062 out_info_new[i].seek = out_info[j].seek;
4063 }
4064 }
4065 }
4066 }
4067 }
4068 }
4069
4070 local_free (out_info);
4071 local_free (out_files);
4072
4073 out_files = out_files_new;
4074 out_cnt = out_cnt_new;
4075 out_info = out_info_new;
4076
4077 folder_mtime = outfile_check_stat.st_mtime;
4078 }
4079
4080 for (int j = 0; j < out_cnt; j++)
4081 {
4082 FILE *fp = fopen (out_info[j].file_name, "rb");
4083
4084 if (fp != NULL)
4085 {
4086 //hc_thread_mutex_lock (mux_display);
4087
4088 #ifdef _POSIX
4089 struct stat outfile_stat;
4090
4091 fstat (fileno (fp), &outfile_stat);
4092 #endif
4093
4094 #ifdef _WIN
4095 struct stat64 outfile_stat;
4096
4097 _fstat64 (fileno (fp), &outfile_stat);
4098 #endif
4099
4100 if (outfile_stat.st_ctime > out_info[j].ctime)
4101 {
4102 out_info[j].ctime = outfile_stat.st_ctime;
4103 out_info[j].seek = 0;
4104 }
4105
4106 fseek (fp, out_info[j].seek, SEEK_SET);
4107
4108 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4109
4110 while (!feof (fp))
4111 {
4112 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4113
4114 if (ptr == NULL) break;
4115
4116 int line_len = strlen (line_buf);
4117
4118 if (line_len <= 0) continue;
4119
4120 int iter = MAX_CUT_TRIES;
4121
4122 for (uint i = line_len - 1; i && iter; i--, line_len--)
4123 {
4124 if (line_buf[i] != separator) continue;
4125
4126 int parser_status = PARSER_OK;
4127
4128 if ((hash_mode != 2500) && (hash_mode != 6800))
4129 {
4130 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4131 }
4132
4133 uint found = 0;
4134
4135 if (parser_status == PARSER_OK)
4136 {
4137 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4138 {
4139 if (data.salts_shown[salt_pos] == 1) continue;
4140
4141 salt_t *salt_buf = &data.salts_buf[salt_pos];
4142
4143 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4144 {
4145 uint idx = salt_buf->digests_offset + digest_pos;
4146
4147 if (data.digests_shown[idx] == 1) continue;
4148
4149 uint cracked = 0;
4150
4151 if (hash_mode == 6800)
4152 {
4153 if (i == salt_buf->salt_len)
4154 {
4155 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4156 }
4157 }
4158 else if (hash_mode == 2500)
4159 {
4160 // BSSID : MAC1 : MAC2 (:plain)
4161 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4162 {
4163 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4164
4165 if (!cracked) continue;
4166
4167 // now compare MAC1 and MAC2 too, since we have this additional info
4168 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4169 char *mac2_pos = mac1_pos + 12 + 1;
4170
4171 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4172 wpa_t *wpa = &wpas[salt_pos];
4173
4174 // compare hex string(s) vs binary MAC address(es)
4175
4176 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4177 {
4178 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4179 {
4180 cracked = 0;
4181
4182 break;
4183 }
4184 }
4185
4186 // early skip ;)
4187 if (!cracked) continue;
4188
4189 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4190 {
4191 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4192 {
4193 cracked = 0;
4194
4195 break;
4196 }
4197 }
4198 }
4199 }
4200 else
4201 {
4202 char *digests_buf_ptr = (char *) data.digests_buf;
4203
4204 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4205
4206 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4207 }
4208
4209 if (cracked == 1)
4210 {
4211 found = 1;
4212
4213 data.digests_shown[idx] = 1;
4214
4215 data.digests_done++;
4216
4217 salt_buf->digests_done++;
4218
4219 if (salt_buf->digests_done == salt_buf->digests_cnt)
4220 {
4221 data.salts_shown[salt_pos] = 1;
4222
4223 data.salts_done++;
4224
4225 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4226 }
4227 }
4228 }
4229
4230 if (data.devices_status == STATUS_CRACKED) break;
4231 }
4232 }
4233
4234 if (found) break;
4235
4236 if (data.devices_status == STATUS_CRACKED) break;
4237
4238 iter--;
4239 }
4240
4241 if (data.devices_status == STATUS_CRACKED) break;
4242 }
4243
4244 myfree (line_buf);
4245
4246 out_info[j].seek = ftell (fp);
4247
4248 //hc_thread_mutex_unlock (mux_display);
4249
4250 fclose (fp);
4251 }
4252 }
4253 }
4254 }
4255
4256 check_left = outfile_check_timer;
4257 }
4258 }
4259
4260 if (esalt_size) local_free (hash_buf.esalt);
4261
4262 if (isSalted) local_free (hash_buf.salt);
4263
4264 local_free (hash_buf.digest);
4265
4266 local_free (out_info);
4267
4268 local_free (out_files);
4269
4270 p = NULL;
4271
4272 return (p);
4273 }
4274
4275 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4276 {
4277 if (device_param->pws_cnt < device_param->kernel_power)
4278 {
4279 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4280
4281 u8 *ptr = (u8 *) pw->i;
4282
4283 memcpy (ptr, pw_buf, pw_len);
4284
4285 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4286
4287 pw->pw_len = pw_len;
4288
4289 device_param->pws_cnt++;
4290 }
4291 else
4292 {
4293 fprintf (stderr, "BUG pw_add()!!\n");
4294
4295 return;
4296 }
4297 }
4298
4299 static uint get_work (hc_device_param_t *device_param, const u64 max, const bool allow_div)
4300 {
4301 hc_thread_mutex_lock (mux_dispatcher);
4302
4303 const u64 words_cur = data.words_cur;
4304 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4305
4306 device_param->words_off = words_cur;
4307
4308 const u64 words_left = words_base - words_cur;
4309
4310 if (allow_div)
4311 {
4312 if (data.kernel_power_all > words_left)
4313 {
4314 if (data.kernel_power_div == 0)
4315 {
4316 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4317 }
4318 }
4319
4320 if (data.kernel_power_div)
4321 {
4322 if (device_param->kernel_power == device_param->kernel_power_user)
4323 {
4324 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4325
4326 if (kernel_power_new < device_param->kernel_power)
4327 {
4328 device_param->kernel_power = kernel_power_new;
4329 }
4330 }
4331 }
4332 }
4333
4334 const uint kernel_power = device_param->kernel_power;
4335
4336 uint work = MIN (words_left, kernel_power);
4337
4338 work = MIN (work, max);
4339
4340 data.words_cur += work;
4341
4342 hc_thread_mutex_unlock (mux_dispatcher);
4343
4344 return work;
4345 }
4346
4347 static void *thread_calc_stdin (void *p)
4348 {
4349 hc_device_param_t *device_param = (hc_device_param_t *) p;
4350
4351 if (device_param->skipped) return NULL;
4352
4353 autotune (device_param);
4354
4355 char *buf = (char *) mymalloc (HCBUFSIZ);
4356
4357 const uint attack_kern = data.attack_kern;
4358
4359 const uint kernel_power = device_param->kernel_power;
4360
4361 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4362 {
4363 hc_thread_mutex_lock (mux_dispatcher);
4364
4365 if (feof (stdin) != 0)
4366 {
4367 hc_thread_mutex_unlock (mux_dispatcher);
4368
4369 break;
4370 }
4371
4372 uint words_cur = 0;
4373
4374 while (words_cur < kernel_power)
4375 {
4376 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4377
4378 if (line_buf == NULL) break;
4379
4380 uint line_len = in_superchop (line_buf);
4381
4382 line_len = convert_from_hex (line_buf, line_len);
4383
4384 // post-process rule engine
4385
4386 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4387 {
4388 char rule_buf_out[BLOCK_SIZE] = { 0 };
4389
4390 int rule_len_out = -1;
4391
4392 if (line_len < BLOCK_SIZE)
4393 {
4394 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4395 }
4396
4397 if (rule_len_out < 0) continue;
4398
4399 line_buf = rule_buf_out;
4400 line_len = rule_len_out;
4401 }
4402
4403 if (line_len > PW_MAX)
4404 {
4405 continue;
4406 }
4407
4408 if (attack_kern == ATTACK_KERN_STRAIGHT)
4409 {
4410 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4411 {
4412 hc_thread_mutex_lock (mux_counter);
4413
4414 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4415 {
4416 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4417 }
4418
4419 hc_thread_mutex_unlock (mux_counter);
4420
4421 continue;
4422 }
4423 }
4424 else if (attack_kern == ATTACK_KERN_COMBI)
4425 {
4426 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4427 // since we still need to combine the plains
4428
4429 if (line_len > data.pw_max)
4430 {
4431 hc_thread_mutex_lock (mux_counter);
4432
4433 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4434 {
4435 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4436 }
4437
4438 hc_thread_mutex_unlock (mux_counter);
4439
4440 continue;
4441 }
4442 }
4443
4444 pw_add (device_param, (u8 *) line_buf, line_len);
4445
4446 words_cur++;
4447
4448 if (data.devices_status == STATUS_CRACKED) break;
4449 if (data.devices_status == STATUS_ABORTED) break;
4450 if (data.devices_status == STATUS_QUIT) break;
4451 if (data.devices_status == STATUS_BYPASS) break;
4452 }
4453
4454 hc_thread_mutex_unlock (mux_dispatcher);
4455
4456 if (data.devices_status == STATUS_CRACKED) break;
4457 if (data.devices_status == STATUS_ABORTED) break;
4458 if (data.devices_status == STATUS_QUIT) break;
4459 if (data.devices_status == STATUS_BYPASS) break;
4460
4461 // flush
4462
4463 const uint pws_cnt = device_param->pws_cnt;
4464
4465 if (pws_cnt)
4466 {
4467 run_copy (device_param, pws_cnt);
4468
4469 run_cracker (device_param, pws_cnt);
4470
4471 device_param->pws_cnt = 0;
4472
4473 if (attack_kern == ATTACK_KERN_STRAIGHT)
4474 {
4475 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4476 }
4477 else if (attack_kern == ATTACK_KERN_COMBI)
4478 {
4479 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4480 }
4481 }
4482 }
4483
4484 device_param->kernel_accel = 0;
4485 device_param->kernel_loops = 0;
4486
4487 myfree (buf);
4488
4489 return NULL;
4490 }
4491
4492 static void *thread_calc (void *p)
4493 {
4494 hc_device_param_t *device_param = (hc_device_param_t *) p;
4495
4496 if (device_param->skipped) return NULL;
4497
4498 autotune (device_param);
4499
4500 const uint attack_mode = data.attack_mode;
4501 const uint attack_kern = data.attack_kern;
4502
4503 if (attack_mode == ATTACK_MODE_BF)
4504 {
4505 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4506 {
4507 const uint work = get_work (device_param, -1, true);
4508
4509 if (work == 0) break;
4510
4511 const u64 words_off = device_param->words_off;
4512 const u64 words_fin = words_off + work;
4513
4514 const uint pws_cnt = work;
4515
4516 device_param->pws_cnt = pws_cnt;
4517
4518 if (pws_cnt)
4519 {
4520 run_copy (device_param, pws_cnt);
4521
4522 run_cracker (device_param, pws_cnt);
4523
4524 device_param->pws_cnt = 0;
4525
4526 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4527 }
4528
4529 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4530
4531 if (data.devices_status == STATUS_CRACKED) break;
4532 if (data.devices_status == STATUS_ABORTED) break;
4533 if (data.devices_status == STATUS_QUIT) break;
4534 if (data.devices_status == STATUS_BYPASS) break;
4535
4536 if (data.benchmark == 1) break;
4537
4538 device_param->words_done = words_fin;
4539 }
4540 }
4541 else
4542 {
4543 const uint segment_size = data.segment_size;
4544
4545 char *dictfile = data.dictfile;
4546
4547 if (attack_mode == ATTACK_MODE_COMBI)
4548 {
4549 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4550 {
4551 dictfile = data.dictfile2;
4552 }
4553 }
4554
4555 FILE *fd = fopen (dictfile, "rb");
4556
4557 if (fd == NULL)
4558 {
4559 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4560
4561 return NULL;
4562 }
4563
4564 if (attack_mode == ATTACK_MODE_COMBI)
4565 {
4566 const uint combs_mode = data.combs_mode;
4567
4568 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4569 {
4570 const char *dictfilec = data.dictfile2;
4571
4572 FILE *combs_fp = fopen (dictfilec, "rb");
4573
4574 if (combs_fp == NULL)
4575 {
4576 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4577
4578 fclose (fd);
4579
4580 return NULL;
4581 }
4582
4583 device_param->combs_fp = combs_fp;
4584 }
4585 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4586 {
4587 const char *dictfilec = data.dictfile;
4588
4589 FILE *combs_fp = fopen (dictfilec, "rb");
4590
4591 if (combs_fp == NULL)
4592 {
4593 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4594
4595 fclose (fd);
4596
4597 return NULL;
4598 }
4599
4600 device_param->combs_fp = combs_fp;
4601 }
4602 }
4603
4604 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4605
4606 wl_data->buf = (char *) mymalloc (segment_size);
4607 wl_data->avail = segment_size;
4608 wl_data->incr = segment_size;
4609 wl_data->cnt = 0;
4610 wl_data->pos = 0;
4611
4612 u64 words_cur = 0;
4613
4614 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4615 {
4616 u64 words_off = 0;
4617 u64 words_fin = 0;
4618
4619 bool allow_div = true;
4620
4621 u64 max = -1;
4622
4623 while (max)
4624 {
4625 const uint work = get_work (device_param, max, allow_div);
4626
4627 allow_div = false;
4628
4629 if (work == 0) break;
4630
4631 words_off = device_param->words_off;
4632 words_fin = words_off + work;
4633
4634 char *line_buf;
4635 uint line_len;
4636
4637 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4638
4639 max = 0;
4640
4641 for ( ; words_cur < words_fin; words_cur++)
4642 {
4643 get_next_word (wl_data, fd, &line_buf, &line_len);
4644
4645 line_len = convert_from_hex (line_buf, line_len);
4646
4647 // post-process rule engine
4648
4649 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4650 {
4651 char rule_buf_out[BLOCK_SIZE] = { 0 };
4652
4653 int rule_len_out = -1;
4654
4655 if (line_len < BLOCK_SIZE)
4656 {
4657 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4658 }
4659
4660 if (rule_len_out < 0) continue;
4661
4662 line_buf = rule_buf_out;
4663 line_len = rule_len_out;
4664 }
4665
4666 if (attack_kern == ATTACK_KERN_STRAIGHT)
4667 {
4668 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4669 {
4670 max++;
4671
4672 hc_thread_mutex_lock (mux_counter);
4673
4674 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4675 {
4676 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4677 }
4678
4679 hc_thread_mutex_unlock (mux_counter);
4680
4681 continue;
4682 }
4683 }
4684 else if (attack_kern == ATTACK_KERN_COMBI)
4685 {
4686 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4687 // since we still need to combine the plains
4688
4689 if (line_len > data.pw_max)
4690 {
4691 max++;
4692
4693 hc_thread_mutex_lock (mux_counter);
4694
4695 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4696 {
4697 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4698 }
4699
4700 hc_thread_mutex_unlock (mux_counter);
4701
4702 continue;
4703 }
4704 }
4705
4706 pw_add (device_param, (u8 *) line_buf, line_len);
4707
4708 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4709
4710 if (data.devices_status == STATUS_CRACKED) break;
4711 if (data.devices_status == STATUS_ABORTED) break;
4712 if (data.devices_status == STATUS_QUIT) break;
4713 if (data.devices_status == STATUS_BYPASS) break;
4714 }
4715
4716 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4717
4718 if (data.devices_status == STATUS_CRACKED) break;
4719 if (data.devices_status == STATUS_ABORTED) break;
4720 if (data.devices_status == STATUS_QUIT) break;
4721 if (data.devices_status == STATUS_BYPASS) break;
4722 }
4723
4724 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4725
4726 if (data.devices_status == STATUS_CRACKED) break;
4727 if (data.devices_status == STATUS_ABORTED) break;
4728 if (data.devices_status == STATUS_QUIT) break;
4729 if (data.devices_status == STATUS_BYPASS) break;
4730
4731 //
4732 // flush
4733 //
4734
4735 const uint pws_cnt = device_param->pws_cnt;
4736
4737 if (pws_cnt)
4738 {
4739 run_copy (device_param, pws_cnt);
4740
4741 run_cracker (device_param, pws_cnt);
4742
4743 device_param->pws_cnt = 0;
4744
4745 if (attack_kern == ATTACK_KERN_STRAIGHT)
4746 {
4747 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4748 }
4749 else if (attack_kern == ATTACK_KERN_COMBI)
4750 {
4751 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4752 }
4753 }
4754
4755 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4756
4757 if (data.devices_status == STATUS_CRACKED) break;
4758 if (data.devices_status == STATUS_ABORTED) break;
4759 if (data.devices_status == STATUS_QUIT) break;
4760 if (data.devices_status == STATUS_BYPASS) break;
4761
4762 if (words_fin == 0) break;
4763
4764 device_param->words_done = words_fin;
4765 }
4766
4767 if (attack_mode == ATTACK_MODE_COMBI)
4768 {
4769 fclose (device_param->combs_fp);
4770 }
4771
4772 free (wl_data->buf);
4773 free (wl_data);
4774
4775 fclose (fd);
4776 }
4777
4778 device_param->kernel_accel = 0;
4779 device_param->kernel_loops = 0;
4780
4781 return NULL;
4782 }
4783
4784 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4785 {
4786 if (!device_param)
4787 {
4788 log_error ("ERROR: %s : Invalid argument", __func__);
4789
4790 exit (-1);
4791 }
4792
4793 salt_t *salt_buf = &data.salts_buf[salt_pos];
4794
4795 device_param->kernel_params_buf32[24] = salt_pos;
4796 device_param->kernel_params_buf32[27] = 1;
4797 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4798 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4799 device_param->kernel_params_buf32[30] = 0;
4800 device_param->kernel_params_buf32[31] = 1;
4801
4802 char *dictfile_old = data.dictfile;
4803
4804 const char *weak_hash_check = "weak-hash-check";
4805
4806 data.dictfile = (char *) weak_hash_check;
4807
4808 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4809
4810 data.kernel_rules_buf[0].cmds[0] = 0;
4811
4812 /**
4813 * run the kernel
4814 */
4815
4816 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4817 {
4818 run_kernel (KERN_RUN_1, device_param, 1, false);
4819 }
4820 else
4821 {
4822 run_kernel (KERN_RUN_1, device_param, 1, false);
4823
4824 uint loop_step = 16;
4825
4826 const uint iter = salt_buf->salt_iter;
4827
4828 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4829 {
4830 uint loop_left = iter - loop_pos;
4831
4832 loop_left = MIN (loop_left, loop_step);
4833
4834 device_param->kernel_params_buf32[25] = loop_pos;
4835 device_param->kernel_params_buf32[26] = loop_left;
4836
4837 run_kernel (KERN_RUN_2, device_param, 1, false);
4838 }
4839
4840 run_kernel (KERN_RUN_3, device_param, 1, false);
4841 }
4842
4843 /**
4844 * result
4845 */
4846
4847 check_cracked (device_param, salt_pos);
4848
4849 /**
4850 * cleanup
4851 */
4852
4853 device_param->kernel_params_buf32[24] = 0;
4854 device_param->kernel_params_buf32[25] = 0;
4855 device_param->kernel_params_buf32[26] = 0;
4856 device_param->kernel_params_buf32[27] = 0;
4857 device_param->kernel_params_buf32[28] = 0;
4858 device_param->kernel_params_buf32[29] = 0;
4859 device_param->kernel_params_buf32[30] = 0;
4860 device_param->kernel_params_buf32[31] = 0;
4861
4862 data.dictfile = dictfile_old;
4863
4864 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4865 }
4866
4867 // hlfmt hashcat
4868
4869 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4870 {
4871 if (data.username == 0)
4872 {
4873 *hashbuf_pos = line_buf;
4874 *hashbuf_len = line_len;
4875 }
4876 else
4877 {
4878 char *pos = line_buf;
4879 int len = line_len;
4880
4881 for (int i = 0; i < line_len; i++, pos++, len--)
4882 {
4883 if (line_buf[i] == data.separator)
4884 {
4885 pos++;
4886
4887 len--;
4888
4889 break;
4890 }
4891 }
4892
4893 *hashbuf_pos = pos;
4894 *hashbuf_len = len;
4895 }
4896 }
4897
4898 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4899 {
4900 char *pos = NULL;
4901 int len = 0;
4902
4903 int sep_cnt = 0;
4904
4905 for (int i = 0; i < line_len; i++)
4906 {
4907 if (line_buf[i] == data.separator)
4908 {
4909 sep_cnt++;
4910
4911 continue;
4912 }
4913
4914 if (sep_cnt == 0)
4915 {
4916 if (pos == NULL) pos = line_buf + i;
4917
4918 len++;
4919 }
4920 }
4921
4922 *userbuf_pos = pos;
4923 *userbuf_len = len;
4924 }
4925
4926 // hlfmt pwdump
4927
4928 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
4929 {
4930 int sep_cnt = 0;
4931
4932 int sep2_len = 0;
4933 int sep3_len = 0;
4934
4935 for (int i = 0; i < line_len; i++)
4936 {
4937 if (line_buf[i] == ':')
4938 {
4939 sep_cnt++;
4940
4941 continue;
4942 }
4943
4944 if (sep_cnt == 2) sep2_len++;
4945 if (sep_cnt == 3) sep3_len++;
4946 }
4947
4948 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4949
4950 return 0;
4951 }
4952
4953 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4954 {
4955 char *pos = NULL;
4956 int len = 0;
4957
4958 int sep_cnt = 0;
4959
4960 for (int i = 0; i < line_len; i++)
4961 {
4962 if (line_buf[i] == ':')
4963 {
4964 sep_cnt++;
4965
4966 continue;
4967 }
4968
4969 if (data.hash_mode == 1000)
4970 {
4971 if (sep_cnt == 3)
4972 {
4973 if (pos == NULL) pos = line_buf + i;
4974
4975 len++;
4976 }
4977 }
4978 else if (data.hash_mode == 3000)
4979 {
4980 if (sep_cnt == 2)
4981 {
4982 if (pos == NULL) pos = line_buf + i;
4983
4984 len++;
4985 }
4986 }
4987 }
4988
4989 *hashbuf_pos = pos;
4990 *hashbuf_len = len;
4991 }
4992
4993 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4994 {
4995 char *pos = NULL;
4996 int len = 0;
4997
4998 int sep_cnt = 0;
4999
5000 for (int i = 0; i < line_len; i++)
5001 {
5002 if (line_buf[i] == ':')
5003 {
5004 sep_cnt++;
5005
5006 continue;
5007 }
5008
5009 if (sep_cnt == 0)
5010 {
5011 if (pos == NULL) pos = line_buf + i;
5012
5013 len++;
5014 }
5015 }
5016
5017 *userbuf_pos = pos;
5018 *userbuf_len = len;
5019 }
5020
5021 // hlfmt passwd
5022
5023 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5024 {
5025 int sep_cnt = 0;
5026
5027 char sep5_first = 0;
5028 char sep6_first = 0;
5029
5030 for (int i = 0; i < line_len; i++)
5031 {
5032 if (line_buf[i] == ':')
5033 {
5034 sep_cnt++;
5035
5036 continue;
5037 }
5038
5039 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5040 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5041 }
5042
5043 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5044
5045 return 0;
5046 }
5047
5048 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5049 {
5050 char *pos = NULL;
5051 int len = 0;
5052
5053 int sep_cnt = 0;
5054
5055 for (int i = 0; i < line_len; i++)
5056 {
5057 if (line_buf[i] == ':')
5058 {
5059 sep_cnt++;
5060
5061 continue;
5062 }
5063
5064 if (sep_cnt == 1)
5065 {
5066 if (pos == NULL) pos = line_buf + i;
5067
5068 len++;
5069 }
5070 }
5071
5072 *hashbuf_pos = pos;
5073 *hashbuf_len = len;
5074 }
5075
5076 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5077 {
5078 char *pos = NULL;
5079 int len = 0;
5080
5081 int sep_cnt = 0;
5082
5083 for (int i = 0; i < line_len; i++)
5084 {
5085 if (line_buf[i] == ':')
5086 {
5087 sep_cnt++;
5088
5089 continue;
5090 }
5091
5092 if (sep_cnt == 0)
5093 {
5094 if (pos == NULL) pos = line_buf + i;
5095
5096 len++;
5097 }
5098 }
5099
5100 *userbuf_pos = pos;
5101 *userbuf_len = len;
5102 }
5103
5104 // hlfmt shadow
5105
5106 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5107 {
5108 int sep_cnt = 0;
5109
5110 for (int i = 0; i < line_len; i++)
5111 {
5112 if (line_buf[i] == ':') sep_cnt++;
5113 }
5114
5115 if (sep_cnt == 8) return 1;
5116
5117 return 0;
5118 }
5119
5120 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5121 {
5122 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5123 }
5124
5125 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5126 {
5127 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5128 }
5129
5130 // hlfmt main
5131
5132 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5133 {
5134 switch (hashfile_format)
5135 {
5136 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5137 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5138 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5139 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5140 }
5141 }
5142
5143 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5144 {
5145 switch (hashfile_format)
5146 {
5147 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5148 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5149 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5150 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5151 }
5152 }
5153
5154 char *strhlfmt (const uint hashfile_format)
5155 {
5156 switch (hashfile_format)
5157 {
5158 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5159 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5160 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5161 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5162 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5163 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5164 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5165 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5166 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5167 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5168 }
5169
5170 return ((char *) "Unknown");
5171 }
5172
5173 static uint hlfmt_detect (FILE *fp, uint max_check)
5174 {
5175 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5176
5177 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5178 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5179
5180 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5181
5182 uint num_check = 0;
5183
5184 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5185
5186 while (!feof (fp))
5187 {
5188 int line_len = fgetl (fp, line_buf);
5189
5190 if (line_len == 0) continue;
5191
5192 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5193 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5194 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5195
5196 if (num_check == max_check) break;
5197
5198 num_check++;
5199 }
5200
5201 myfree (line_buf);
5202
5203 uint hashlist_format = HLFMT_HASHCAT;
5204
5205 for (int i = 1; i < HLFMTS_CNT; i++)
5206 {
5207 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5208
5209 hashlist_format = i;
5210 }
5211
5212 free (formats_cnt);
5213
5214 return hashlist_format;
5215 }
5216
5217 /**
5218 * some further helper function
5219 */
5220
5221 // wrapper around mymalloc for ADL
5222
5223 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5224 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5225 {
5226 return mymalloc (iSize);
5227 }
5228 #endif
5229
5230 static uint generate_bitmaps (const uint digests_cnt, const uint dgst_size, const uint dgst_shifts, char *digests_buf_ptr, const uint bitmap_mask, const uint bitmap_size, uint *bitmap_a, uint *bitmap_b, uint *bitmap_c, uint *bitmap_d, const u64 collisions_max)
5231 {
5232 u64 collisions = 0;
5233
5234 const uint dgst_pos0 = data.dgst_pos0;
5235 const uint dgst_pos1 = data.dgst_pos1;
5236 const uint dgst_pos2 = data.dgst_pos2;
5237 const uint dgst_pos3 = data.dgst_pos3;
5238
5239 memset (bitmap_a, 0, bitmap_size);
5240 memset (bitmap_b, 0, bitmap_size);
5241 memset (bitmap_c, 0, bitmap_size);
5242 memset (bitmap_d, 0, bitmap_size);
5243
5244 for (uint i = 0; i < digests_cnt; i++)
5245 {
5246 uint *digest_ptr = (uint *) digests_buf_ptr;
5247
5248 digests_buf_ptr += dgst_size;
5249
5250 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5251 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5252 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5253 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5254
5255 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5256 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5257 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5258 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5259
5260 if (bitmap_a[idx0] & val0) collisions++;
5261 if (bitmap_b[idx1] & val1) collisions++;
5262 if (bitmap_c[idx2] & val2) collisions++;
5263 if (bitmap_d[idx3] & val3) collisions++;
5264
5265 bitmap_a[idx0] |= val0;
5266 bitmap_b[idx1] |= val1;
5267 bitmap_c[idx2] |= val2;
5268 bitmap_d[idx3] |= val3;
5269
5270 if (collisions >= collisions_max) return 0x7fffffff;
5271 }
5272
5273 return collisions;
5274 }
5275
5276 /**
5277 * main
5278 */
5279
5280 int main (int argc, char **argv)
5281 {
5282 /**
5283 * To help users a bit
5284 */
5285
5286 char *compute = getenv ("COMPUTE");
5287
5288 if (compute)
5289 {
5290 static char display[100];
5291
5292 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5293
5294 putenv (display);
5295 }
5296 else
5297 {
5298 if (getenv ("DISPLAY") == NULL)
5299 putenv ((char *) "DISPLAY=:0");
5300 }
5301
5302 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5303 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5304
5305 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5306 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5307
5308 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5309 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5310
5311 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5312 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5313
5314 /**
5315 * Real init
5316 */
5317
5318 memset (&data, 0, sizeof (hc_global_data_t));
5319
5320 time_t proc_start;
5321
5322 time (&proc_start);
5323
5324 data.proc_start = proc_start;
5325
5326 int myargc = argc;
5327 char **myargv = argv;
5328
5329 hc_thread_mutex_init (mux_dispatcher);
5330 hc_thread_mutex_init (mux_counter);
5331 hc_thread_mutex_init (mux_display);
5332 hc_thread_mutex_init (mux_adl);
5333
5334 /**
5335 * commandline parameters
5336 */
5337
5338 uint usage = USAGE;
5339 uint version = VERSION;
5340 uint quiet = QUIET;
5341 uint benchmark = BENCHMARK;
5342 uint benchmark_repeats = BENCHMARK_REPEATS;
5343 uint show = SHOW;
5344 uint left = LEFT;
5345 uint username = USERNAME;
5346 uint remove = REMOVE;
5347 uint remove_timer = REMOVE_TIMER;
5348 u64 skip = SKIP;
5349 u64 limit = LIMIT;
5350 uint keyspace = KEYSPACE;
5351 uint potfile_disable = POTFILE_DISABLE;
5352 char *potfile_path = NULL;
5353 uint debug_mode = DEBUG_MODE;
5354 char *debug_file = NULL;
5355 char *induction_dir = NULL;
5356 char *outfile_check_dir = NULL;
5357 uint force = FORCE;
5358 uint runtime = RUNTIME;
5359 uint hash_mode = HASH_MODE;
5360 uint attack_mode = ATTACK_MODE;
5361 uint markov_disable = MARKOV_DISABLE;
5362 uint markov_classic = MARKOV_CLASSIC;
5363 uint markov_threshold = MARKOV_THRESHOLD;
5364 char *markov_hcstat = NULL;
5365 char *outfile = NULL;
5366 uint outfile_format = OUTFILE_FORMAT;
5367 uint outfile_autohex = OUTFILE_AUTOHEX;
5368 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5369 uint restore = RESTORE;
5370 uint restore_timer = RESTORE_TIMER;
5371 uint restore_disable = RESTORE_DISABLE;
5372 uint status = STATUS;
5373 uint status_timer = STATUS_TIMER;
5374 uint status_automat = STATUS_AUTOMAT;
5375 uint loopback = LOOPBACK;
5376 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5377 char *session = NULL;
5378 uint hex_charset = HEX_CHARSET;
5379 uint hex_salt = HEX_SALT;
5380 uint hex_wordlist = HEX_WORDLIST;
5381 uint rp_gen = RP_GEN;
5382 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5383 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5384 uint rp_gen_seed = RP_GEN_SEED;
5385 char *rule_buf_l = (char *) RULE_BUF_L;
5386 char *rule_buf_r = (char *) RULE_BUF_R;
5387 uint increment = INCREMENT;
5388 uint increment_min = INCREMENT_MIN;
5389 uint increment_max = INCREMENT_MAX;
5390 char *cpu_affinity = NULL;
5391 OCL_PTR *ocl = NULL;
5392 char *opencl_devices = NULL;
5393 char *opencl_platforms = NULL;
5394 char *opencl_device_types = NULL;
5395 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5396 char *truecrypt_keyfiles = NULL;
5397 uint workload_profile = WORKLOAD_PROFILE;
5398 uint kernel_accel = KERNEL_ACCEL;
5399 uint kernel_loops = KERNEL_LOOPS;
5400 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5401 #ifdef HAVE_HWMON
5402 uint gpu_temp_abort = GPU_TEMP_ABORT;
5403 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5404 #ifdef HAVE_ADL
5405 uint powertune_enable = POWERTUNE_ENABLE;
5406 #endif
5407 #endif
5408 uint logfile_disable = LOGFILE_DISABLE;
5409 uint segment_size = SEGMENT_SIZE;
5410 uint scrypt_tmto = SCRYPT_TMTO;
5411 char separator = SEPARATOR;
5412 uint bitmap_min = BITMAP_MIN;
5413 uint bitmap_max = BITMAP_MAX;
5414 char *custom_charset_1 = NULL;
5415 char *custom_charset_2 = NULL;
5416 char *custom_charset_3 = NULL;
5417 char *custom_charset_4 = NULL;
5418
5419 #define IDX_HELP 'h'
5420 #define IDX_VERSION 'V'
5421 #define IDX_VERSION_LOWER 'v'
5422 #define IDX_QUIET 0xff02
5423 #define IDX_SHOW 0xff03
5424 #define IDX_LEFT 0xff04
5425 #define IDX_REMOVE 0xff05
5426 #define IDX_REMOVE_TIMER 0xff37
5427 #define IDX_SKIP 's'
5428 #define IDX_LIMIT 'l'
5429 #define IDX_KEYSPACE 0xff35
5430 #define IDX_POTFILE_DISABLE 0xff06
5431 #define IDX_POTFILE_PATH 0xffe0
5432 #define IDX_DEBUG_MODE 0xff43
5433 #define IDX_DEBUG_FILE 0xff44
5434 #define IDX_INDUCTION_DIR 0xff46
5435 #define IDX_OUTFILE_CHECK_DIR 0xff47
5436 #define IDX_USERNAME 0xff07
5437 #define IDX_FORCE 0xff08
5438 #define IDX_RUNTIME 0xff09
5439 #define IDX_BENCHMARK 'b'
5440 #define IDX_BENCHMARK_REPEATS 0xff78
5441 #define IDX_HASH_MODE 'm'
5442 #define IDX_ATTACK_MODE 'a'
5443 #define IDX_RP_FILE 'r'
5444 #define IDX_RP_GEN 'g'
5445 #define IDX_RP_GEN_FUNC_MIN 0xff10
5446 #define IDX_RP_GEN_FUNC_MAX 0xff11
5447 #define IDX_RP_GEN_SEED 0xff34
5448 #define IDX_RULE_BUF_L 'j'
5449 #define IDX_RULE_BUF_R 'k'
5450 #define IDX_INCREMENT 'i'
5451 #define IDX_INCREMENT_MIN 0xff12
5452 #define IDX_INCREMENT_MAX 0xff13
5453 #define IDX_OUTFILE 'o'
5454 #define IDX_OUTFILE_FORMAT 0xff14
5455 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5456 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5457 #define IDX_RESTORE 0xff15
5458 #define IDX_RESTORE_DISABLE 0xff27
5459 #define IDX_STATUS 0xff17
5460 #define IDX_STATUS_TIMER 0xff18
5461 #define IDX_STATUS_AUTOMAT 0xff50
5462 #define IDX_LOOPBACK 0xff38
5463 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5464 #define IDX_SESSION 0xff19
5465 #define IDX_HEX_CHARSET 0xff20
5466 #define IDX_HEX_SALT 0xff21
5467 #define IDX_HEX_WORDLIST 0xff40
5468 #define IDX_MARKOV_DISABLE 0xff22
5469 #define IDX_MARKOV_CLASSIC 0xff23
5470 #define IDX_MARKOV_THRESHOLD 't'
5471 #define IDX_MARKOV_HCSTAT 0xff24
5472 #define IDX_CPU_AFFINITY 0xff25
5473 #define IDX_OPENCL_DEVICES 'd'
5474 #define IDX_OPENCL_PLATFORMS 0xff72
5475 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5476 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5477 #define IDX_WORKLOAD_PROFILE 'w'
5478 #define IDX_KERNEL_ACCEL 'n'
5479 #define IDX_KERNEL_LOOPS 'u'
5480 #define IDX_GPU_TEMP_DISABLE 0xff29
5481 #define IDX_GPU_TEMP_ABORT 0xff30
5482 #define IDX_GPU_TEMP_RETAIN 0xff31
5483 #define IDX_POWERTUNE_ENABLE 0xff41
5484 #define IDX_LOGFILE_DISABLE 0xff51
5485 #define IDX_TRUECRYPT_KEYFILES 0xff52
5486 #define IDX_SCRYPT_TMTO 0xff61
5487 #define IDX_SEGMENT_SIZE 'c'
5488 #define IDX_SEPARATOR 'p'
5489 #define IDX_BITMAP_MIN 0xff70
5490 #define IDX_BITMAP_MAX 0xff71
5491 #define IDX_CUSTOM_CHARSET_1 '1'
5492 #define IDX_CUSTOM_CHARSET_2 '2'
5493 #define IDX_CUSTOM_CHARSET_3 '3'
5494 #define IDX_CUSTOM_CHARSET_4 '4'
5495
5496 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5497
5498 struct option long_options[] =
5499 {
5500 {"help", no_argument, 0, IDX_HELP},
5501 {"version", no_argument, 0, IDX_VERSION},
5502 {"quiet", no_argument, 0, IDX_QUIET},
5503 {"show", no_argument, 0, IDX_SHOW},
5504 {"left", no_argument, 0, IDX_LEFT},
5505 {"username", no_argument, 0, IDX_USERNAME},
5506 {"remove", no_argument, 0, IDX_REMOVE},
5507 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5508 {"skip", required_argument, 0, IDX_SKIP},
5509 {"limit", required_argument, 0, IDX_LIMIT},
5510 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5511 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5512 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5513 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5514 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5515 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5516 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5517 {"force", no_argument, 0, IDX_FORCE},
5518 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5519 {"benchmark-repeats", required_argument, 0, IDX_BENCHMARK_REPEATS},
5520 {"restore", no_argument, 0, IDX_RESTORE},
5521 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5522 {"status", no_argument, 0, IDX_STATUS},
5523 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5524 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5525 {"loopback", no_argument, 0, IDX_LOOPBACK},
5526 {"weak-hash-threshold",
5527 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5528 {"session", required_argument, 0, IDX_SESSION},
5529 {"runtime", required_argument, 0, IDX_RUNTIME},
5530 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5531 {"generate-rules-func-min",
5532 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5533 {"generate-rules-func-max",
5534 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5535 {"generate-rules-seed",
5536 required_argument, 0, IDX_RP_GEN_SEED},
5537 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5538 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5539 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5540 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5541 {"rules-file", required_argument, 0, IDX_RP_FILE},
5542 {"outfile", required_argument, 0, IDX_OUTFILE},
5543 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5544 {"outfile-autohex-disable",
5545 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5546 {"outfile-check-timer",
5547 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5548 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5549 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5550 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5551 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5552 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5553 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5554 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5555 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5556 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5557 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5558 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5559 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5560 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5561 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5562 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5563 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5564 #ifdef HAVE_HWMON
5565 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5566 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5567 #ifdef HAVE_ADL
5568 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5569 #endif
5570 #endif // HAVE_HWMON
5571 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5572 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5573 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5574 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5575 // deprecated
5576 {"seperator", required_argument, 0, IDX_SEPARATOR},
5577 {"separator", required_argument, 0, IDX_SEPARATOR},
5578 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5579 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5580 {"increment", no_argument, 0, IDX_INCREMENT},
5581 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5582 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5583 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5584 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5585 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5586 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5587
5588 {0, 0, 0, 0}
5589 };
5590
5591 uint rp_files_cnt = 0;
5592
5593 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5594
5595 int option_index = 0;
5596 int c = -1;
5597
5598 optind = 1;
5599 optopt = 0;
5600
5601 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5602 {
5603 switch (c)
5604 {
5605 case IDX_HELP: usage = 1; break;
5606 case IDX_VERSION:
5607 case IDX_VERSION_LOWER: version = 1; break;
5608 case IDX_RESTORE: restore = 1; break;
5609 case IDX_SESSION: session = optarg; break;
5610 case IDX_SHOW: show = 1; break;
5611 case IDX_LEFT: left = 1; break;
5612 case '?': return (-1);
5613 }
5614 }
5615
5616 if (optopt != 0)
5617 {
5618 log_error ("ERROR: Invalid argument specified");
5619
5620 return (-1);
5621 }
5622
5623 /**
5624 * exit functions
5625 */
5626
5627 if (version)
5628 {
5629 log_info ("%s (%s)", VERSION_TAG, VERSION_SUM);
5630
5631 return (0);
5632 }
5633
5634 if (usage)
5635 {
5636 usage_big_print (PROGNAME);
5637
5638 return (0);
5639 }
5640
5641 /**
5642 * session needs to be set, always!
5643 */
5644
5645 if (session == NULL) session = (char *) PROGNAME;
5646
5647 /**
5648 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5649 */
5650
5651 char *exec_path = get_exec_path ();
5652
5653 #ifdef LINUX
5654
5655 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5656 char *resolved_exec_path = realpath (exec_path, NULL);
5657
5658 char *install_dir = get_install_dir (resolved_exec_path);
5659 char *profile_dir = NULL;
5660 char *session_dir = NULL;
5661 char *shared_dir = NULL;
5662
5663 if (strcmp (install_dir, resolved_install_folder) == 0)
5664 {
5665 struct passwd *pw = getpwuid (getuid ());
5666
5667 const char *homedir = pw->pw_dir;
5668
5669 profile_dir = get_profile_dir (homedir);
5670 session_dir = get_session_dir (profile_dir);
5671 shared_dir = strdup (SHARED_FOLDER);
5672
5673 mkdir (profile_dir, 0700);
5674 mkdir (session_dir, 0700);
5675 }
5676 else
5677 {
5678 profile_dir = install_dir;
5679 session_dir = install_dir;
5680 shared_dir = install_dir;
5681 }
5682
5683 myfree (resolved_install_folder);
5684 myfree (resolved_exec_path);
5685
5686 #else
5687
5688 char *install_dir = get_install_dir (exec_path);
5689 char *profile_dir = install_dir;
5690 char *session_dir = install_dir;
5691 char *shared_dir = install_dir;
5692
5693 #endif
5694
5695 data.install_dir = install_dir;
5696 data.profile_dir = profile_dir;
5697 data.session_dir = session_dir;
5698 data.shared_dir = shared_dir;
5699
5700 myfree (exec_path);
5701
5702 /**
5703 * kernel cache, we need to make sure folder exist
5704 */
5705
5706 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5707
5708 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5709
5710 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5711
5712 mkdir (kernels_folder, 0700);
5713
5714 myfree (kernels_folder);
5715
5716 /**
5717 * session
5718 */
5719
5720 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5721
5722 data.session = session;
5723
5724 char *eff_restore_file = (char *) mymalloc (session_size);
5725 char *new_restore_file = (char *) mymalloc (session_size);
5726
5727 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5728 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5729
5730 data.eff_restore_file = eff_restore_file;
5731 data.new_restore_file = new_restore_file;
5732
5733 if (((show == 1) || (left == 1)) && (restore == 1))
5734 {
5735 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5736 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5737
5738 return (-1);
5739 }
5740
5741 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5742 if ((show == 1) || (left == 1))
5743 {
5744 restore_disable = 1;
5745
5746 restore = 0;
5747 }
5748
5749 data.restore_disable = restore_disable;
5750
5751 restore_data_t *rd = init_restore (argc, argv);
5752
5753 data.rd = rd;
5754
5755 /**
5756 * restore file
5757 */
5758
5759 if (restore == 1)
5760 {
5761 read_restore (eff_restore_file, rd);
5762
5763 if (rd->version_bin < RESTORE_MIN)
5764 {
5765 log_error ("ERROR: Incompatible restore-file version");
5766
5767 return (-1);
5768 }
5769
5770 myargc = rd->argc;
5771 myargv = rd->argv;
5772
5773 #ifdef _POSIX
5774 rd->pid = getpid ();
5775 #elif _WIN
5776 rd->pid = GetCurrentProcessId ();
5777 #endif
5778 }
5779
5780 uint hash_mode_chgd = 0;
5781 uint runtime_chgd = 0;
5782 uint kernel_loops_chgd = 0;
5783 uint kernel_accel_chgd = 0;
5784 uint attack_mode_chgd = 0;
5785 uint outfile_format_chgd = 0;
5786 uint rp_gen_seed_chgd = 0;
5787 uint remove_timer_chgd = 0;
5788 uint increment_min_chgd = 0;
5789 uint increment_max_chgd = 0;
5790 uint workload_profile_chgd = 0;
5791 uint opencl_vector_width_chgd = 0;
5792
5793 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5794 uint gpu_temp_retain_chgd = 0;
5795 uint gpu_temp_abort_chgd = 0;
5796 #endif
5797
5798 optind = 1;
5799 optopt = 0;
5800 option_index = 0;
5801
5802 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5803 {
5804 switch (c)
5805 {
5806 //case IDX_HELP: usage = 1; break;
5807 //case IDX_VERSION: version = 1; break;
5808 //case IDX_RESTORE: restore = 1; break;
5809 case IDX_QUIET: quiet = 1; break;
5810 //case IDX_SHOW: show = 1; break;
5811 case IDX_SHOW: break;
5812 //case IDX_LEFT: left = 1; break;
5813 case IDX_LEFT: break;
5814 case IDX_USERNAME: username = 1; break;
5815 case IDX_REMOVE: remove = 1; break;
5816 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5817 remove_timer_chgd = 1; break;
5818 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5819 case IDX_POTFILE_PATH: potfile_path = optarg; break;
5820 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5821 case IDX_DEBUG_FILE: debug_file = optarg; break;
5822 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5823 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5824 case IDX_FORCE: force = 1; break;
5825 case IDX_SKIP: skip = atoll (optarg); break;
5826 case IDX_LIMIT: limit = atoll (optarg); break;
5827 case IDX_KEYSPACE: keyspace = 1; break;
5828 case IDX_BENCHMARK: benchmark = 1; break;
5829 case IDX_BENCHMARK_REPEATS: benchmark_repeats = atoi (optarg); break;
5830 case IDX_RESTORE: break;
5831 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5832 case IDX_STATUS: status = 1; break;
5833 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5834 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5835 case IDX_LOOPBACK: loopback = 1; break;
5836 case IDX_WEAK_HASH_THRESHOLD:
5837 weak_hash_threshold = atoi (optarg); break;
5838 //case IDX_SESSION: session = optarg; break;
5839 case IDX_SESSION: break;
5840 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5841 hash_mode_chgd = 1; break;
5842 case IDX_RUNTIME: runtime = atoi (optarg);
5843 runtime_chgd = 1; break;
5844 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5845 attack_mode_chgd = 1; break;
5846 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5847 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5848 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5849 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5850 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5851 rp_gen_seed_chgd = 1; break;
5852 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5853 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5854 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5855 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5856 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5857 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5858 case IDX_OUTFILE: outfile = optarg; break;
5859 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5860 outfile_format_chgd = 1; break;
5861 case IDX_OUTFILE_AUTOHEX_DISABLE:
5862 outfile_autohex = 0; break;
5863 case IDX_OUTFILE_CHECK_TIMER:
5864 outfile_check_timer = atoi (optarg); break;
5865 case IDX_HEX_CHARSET: hex_charset = 1; break;
5866 case IDX_HEX_SALT: hex_salt = 1; break;
5867 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5868 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5869 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5870 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5871 case IDX_OPENCL_DEVICE_TYPES:
5872 opencl_device_types = optarg; break;
5873 case IDX_OPENCL_VECTOR_WIDTH:
5874 opencl_vector_width = atoi (optarg);
5875 opencl_vector_width_chgd = 1; break;
5876 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
5877 workload_profile_chgd = 1; break;
5878 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5879 kernel_accel_chgd = 1; break;
5880 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5881 kernel_loops_chgd = 1; break;
5882 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5883 #ifdef HAVE_HWMON
5884 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5885 #ifdef HAVE_ADL
5886 gpu_temp_abort_chgd = 1;
5887 #endif
5888 break;
5889 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5890 #ifdef HAVE_ADL
5891 gpu_temp_retain_chgd = 1;
5892 #endif
5893 break;
5894 #ifdef HAVE_ADL
5895 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5896 #endif
5897 #endif // HAVE_HWMON
5898 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5899 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5900 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5901 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5902 case IDX_SEPARATOR: separator = optarg[0]; break;
5903 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5904 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5905 case IDX_INCREMENT: increment = 1; break;
5906 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5907 increment_min_chgd = 1; break;
5908 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5909 increment_max_chgd = 1; break;
5910 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5911 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5912 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5913 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5914
5915 default:
5916 log_error ("ERROR: Invalid argument specified");
5917 return (-1);
5918 }
5919 }
5920
5921 if (optopt != 0)
5922 {
5923 log_error ("ERROR: Invalid argument specified");
5924
5925 return (-1);
5926 }
5927
5928 /**
5929 * Inform user things getting started,
5930 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5931 * - we do not need to check algorithm_pos
5932 */
5933
5934 if (quiet == 0)
5935 {
5936 if (benchmark == 1)
5937 {
5938 log_info ("%s %s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5939
5940 log_info ("");
5941 }
5942 else if (restore == 1)
5943 {
5944 log_info ("%s %s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5945
5946 log_info ("");
5947 }
5948 else
5949 {
5950 log_info ("%s %s (%s) starting...", PROGNAME, VERSION_TAG, VERSION_SUM);
5951
5952 log_info ("");
5953 }
5954 }
5955
5956 /**
5957 * sanity check
5958 */
5959
5960 if (attack_mode > 7)
5961 {
5962 log_error ("ERROR: Invalid attack-mode specified");
5963
5964 return (-1);
5965 }
5966
5967 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5968 {
5969 log_error ("ERROR: Invalid runtime specified");
5970
5971 return (-1);
5972 }
5973
5974 if (hash_mode_chgd && hash_mode > 13400) // just added to remove compiler warnings for hash_mode_chgd
5975 {
5976 log_error ("ERROR: Invalid hash-type specified");
5977
5978 return (-1);
5979 }
5980
5981 // renamed hash modes
5982
5983 if (hash_mode_chgd)
5984 {
5985 int n = -1;
5986
5987 switch (hash_mode)
5988 {
5989 case 123: n = 124;
5990 break;
5991 }
5992
5993 if (n >= 0)
5994 {
5995 log_error ("Old -m specified, use -m %d instead", n);
5996
5997 return (-1);
5998 }
5999 }
6000
6001 if (username == 1)
6002 {
6003 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
6004 {
6005 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6006
6007 return (-1);
6008 }
6009 }
6010
6011 if (outfile_format > 16)
6012 {
6013 log_error ("ERROR: Invalid outfile-format specified");
6014
6015 return (-1);
6016 }
6017
6018 if (left == 1)
6019 {
6020 if (outfile_format_chgd == 1)
6021 {
6022 if (outfile_format > 1)
6023 {
6024 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6025
6026 return (-1);
6027 }
6028 }
6029 else
6030 {
6031 outfile_format = OUTFILE_FMT_HASH;
6032 }
6033 }
6034
6035 if (show == 1)
6036 {
6037 if (outfile_format_chgd == 1)
6038 {
6039 if ((outfile_format > 7) && (outfile_format < 16))
6040 {
6041 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6042
6043 return (-1);
6044 }
6045 }
6046 }
6047
6048 if (increment_min < INCREMENT_MIN)
6049 {
6050 log_error ("ERROR: Invalid increment-min specified");
6051
6052 return (-1);
6053 }
6054
6055 if (increment_max > INCREMENT_MAX)
6056 {
6057 log_error ("ERROR: Invalid increment-max specified");
6058
6059 return (-1);
6060 }
6061
6062 if (increment_min > increment_max)
6063 {
6064 log_error ("ERROR: Invalid increment-min specified");
6065
6066 return (-1);
6067 }
6068
6069 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6070 {
6071 log_error ("ERROR: increment is not allowed in attack-mode 0");
6072
6073 return (-1);
6074 }
6075
6076 if ((increment == 0) && (increment_min_chgd == 1))
6077 {
6078 log_error ("ERROR: increment-min is only supported together with increment switch");
6079
6080 return (-1);
6081 }
6082
6083 if ((increment == 0) && (increment_max_chgd == 1))
6084 {
6085 log_error ("ERROR: increment-max is only supported together with increment switch");
6086
6087 return (-1);
6088 }
6089
6090 if (rp_files_cnt && rp_gen)
6091 {
6092 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6093
6094 return (-1);
6095 }
6096
6097 if (rp_files_cnt || rp_gen)
6098 {
6099 if (attack_mode != ATTACK_MODE_STRAIGHT)
6100 {
6101 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6102
6103 return (-1);
6104 }
6105 }
6106
6107 if (rp_gen_func_min > rp_gen_func_max)
6108 {
6109 log_error ("ERROR: Invalid rp-gen-func-min specified");
6110
6111 return (-1);
6112 }
6113
6114 if (kernel_accel_chgd == 1)
6115 {
6116 if (kernel_accel < 1)
6117 {
6118 log_error ("ERROR: Invalid kernel-accel specified");
6119
6120 return (-1);
6121 }
6122
6123 if (kernel_accel > 1024)
6124 {
6125 log_error ("ERROR: Invalid kernel-accel specified");
6126
6127 return (-1);
6128 }
6129 }
6130
6131 if (kernel_loops_chgd == 1)
6132 {
6133 if (kernel_loops < 1)
6134 {
6135 log_error ("ERROR: Invalid kernel-loops specified");
6136
6137 return (-1);
6138 }
6139
6140 if (kernel_loops > 1024)
6141 {
6142 log_error ("ERROR: Invalid kernel-loops specified");
6143
6144 return (-1);
6145 }
6146 }
6147
6148 if ((workload_profile < 1) || (workload_profile > 3))
6149 {
6150 log_error ("ERROR: workload-profile %i not available", workload_profile);
6151
6152 return (-1);
6153 }
6154
6155 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6156 {
6157 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6158
6159 return (-1);
6160 }
6161
6162 if (show == 1 || left == 1)
6163 {
6164 attack_mode = ATTACK_MODE_NONE;
6165
6166 if (remove == 1)
6167 {
6168 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6169
6170 return (-1);
6171 }
6172
6173 if (potfile_disable == 1)
6174 {
6175 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6176
6177 return (-1);
6178 }
6179 }
6180
6181 uint attack_kern = ATTACK_KERN_NONE;
6182
6183 switch (attack_mode)
6184 {
6185 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6186 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6187 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6188 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6189 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6190 }
6191
6192 if (benchmark == 0)
6193 {
6194 if (keyspace == 1)
6195 {
6196 int num_additional_params = 1;
6197
6198 if (attack_kern == ATTACK_KERN_COMBI)
6199 {
6200 num_additional_params = 2;
6201 }
6202
6203 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6204
6205 if (keyspace_wordlist_specified == 0) optind--;
6206 }
6207
6208 if (attack_kern == ATTACK_KERN_NONE)
6209 {
6210 if ((optind + 1) != myargc)
6211 {
6212 usage_mini_print (myargv[0]);
6213
6214 return (-1);
6215 }
6216 }
6217 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6218 {
6219 if ((optind + 1) > myargc)
6220 {
6221 usage_mini_print (myargv[0]);
6222
6223 return (-1);
6224 }
6225 }
6226 else if (attack_kern == ATTACK_KERN_COMBI)
6227 {
6228 if ((optind + 3) != myargc)
6229 {
6230 usage_mini_print (myargv[0]);
6231
6232 return (-1);
6233 }
6234 }
6235 else if (attack_kern == ATTACK_KERN_BF)
6236 {
6237 if ((optind + 1) > myargc)
6238 {
6239 usage_mini_print (myargv[0]);
6240
6241 return (-1);
6242 }
6243 }
6244 else
6245 {
6246 usage_mini_print (myargv[0]);
6247
6248 return (-1);
6249 }
6250 }
6251 else
6252 {
6253 if (myargv[optind] != 0)
6254 {
6255 log_error ("ERROR: Invalid argument for benchmark mode specified");
6256
6257 return (-1);
6258 }
6259
6260 if (attack_mode_chgd == 1)
6261 {
6262 if (attack_mode != ATTACK_MODE_BF)
6263 {
6264 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6265
6266 return (-1);
6267 }
6268 }
6269 }
6270
6271 if (skip != 0 && limit != 0)
6272 {
6273 limit += skip;
6274 }
6275
6276 if (keyspace == 1)
6277 {
6278 if (show == 1)
6279 {
6280 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6281
6282 return (-1);
6283 }
6284 else if (left == 1)
6285 {
6286 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6287
6288 return (-1);
6289 }
6290
6291 potfile_disable = 1;
6292
6293 restore_disable = 1;
6294
6295 restore = 0;
6296
6297 weak_hash_threshold = 0;
6298
6299 quiet = 1;
6300 }
6301
6302 if (remove_timer_chgd == 1)
6303 {
6304 if (remove == 0)
6305 {
6306 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6307
6308 return (-1);
6309 }
6310
6311 if (remove_timer < 1)
6312 {
6313 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6314
6315 return (-1);
6316 }
6317 }
6318
6319 if (loopback == 1)
6320 {
6321 if (attack_mode == ATTACK_MODE_BF)
6322 {
6323 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
6324
6325 return (-1);
6326 }
6327 else if (attack_mode == ATTACK_MODE_STRAIGHT)
6328 {
6329 if ((rp_files_cnt == 0) && (rp_gen == 0))
6330 {
6331 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6332
6333 return (-1);
6334 }
6335 }
6336 }
6337
6338 if (debug_mode > 0)
6339 {
6340 if (attack_mode != ATTACK_MODE_STRAIGHT)
6341 {
6342 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6343
6344 return (-1);
6345 }
6346
6347 if ((rp_files_cnt == 0) && (rp_gen == 0))
6348 {
6349 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6350
6351 return (-1);
6352 }
6353 }
6354
6355 if (debug_mode > 4)
6356 {
6357 log_error ("ERROR: Invalid debug-mode specified");
6358
6359 return (-1);
6360 }
6361
6362 if (debug_file != NULL)
6363 {
6364 if (debug_mode < 1)
6365 {
6366 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6367
6368 return (-1);
6369 }
6370 }
6371
6372 if (induction_dir != NULL)
6373 {
6374 if (attack_mode == ATTACK_MODE_BF)
6375 {
6376 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6377
6378 return (-1);
6379 }
6380 }
6381
6382 if (attack_mode != ATTACK_MODE_STRAIGHT)
6383 {
6384 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6385 {
6386 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6387
6388 return (-1);
6389 }
6390
6391 weak_hash_threshold = 0;
6392 }
6393
6394 /**
6395 * induction directory
6396 */
6397
6398 char *induction_directory = NULL;
6399
6400 if (attack_mode != ATTACK_MODE_BF)
6401 {
6402 if (induction_dir == NULL)
6403 {
6404 induction_directory = (char *) mymalloc (session_size);
6405
6406 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6407
6408 // create induction folder if it does not already exist
6409
6410 if (keyspace == 0)
6411 {
6412 if (rmdir (induction_directory) == -1)
6413 {
6414 if (errno == ENOENT)
6415 {
6416 // good, we can ignore
6417 }
6418 else if (errno == ENOTEMPTY)
6419 {
6420 char *induction_directory_mv = (char *) mymalloc (session_size);
6421
6422 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6423
6424 if (rename (induction_directory, induction_directory_mv) != 0)
6425 {
6426 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6427
6428 return (-1);
6429 }
6430 }
6431 else
6432 {
6433 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6434
6435 return (-1);
6436 }
6437 }
6438
6439 if (mkdir (induction_directory, 0700) == -1)
6440 {
6441 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6442
6443 return (-1);
6444 }
6445 }
6446 }
6447 else
6448 {
6449 induction_directory = induction_dir;
6450 }
6451 }
6452
6453 data.induction_directory = induction_directory;
6454
6455 /**
6456 * loopback
6457 */
6458
6459 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6460
6461 char *loopback_file = (char *) mymalloc (loopback_size);
6462
6463 /**
6464 * tuning db
6465 */
6466
6467 char tuning_db_file[256] = { 0 };
6468
6469 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6470
6471 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6472
6473 /**
6474 * outfile-check directory
6475 */
6476
6477 char *outfile_check_directory = NULL;
6478
6479 if (outfile_check_dir == NULL)
6480 {
6481 outfile_check_directory = (char *) mymalloc (session_size);
6482
6483 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6484 }
6485 else
6486 {
6487 outfile_check_directory = outfile_check_dir;
6488 }
6489
6490 data.outfile_check_directory = outfile_check_directory;
6491
6492 if (keyspace == 0)
6493 {
6494 struct stat outfile_check_stat;
6495
6496 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6497 {
6498 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6499
6500 if (is_dir == 0)
6501 {
6502 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6503
6504 return (-1);
6505 }
6506 }
6507 else if (outfile_check_dir == NULL)
6508 {
6509 if (mkdir (outfile_check_directory, 0700) == -1)
6510 {
6511 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6512
6513 return (-1);
6514 }
6515 }
6516 }
6517
6518 /**
6519 * special other stuff
6520 */
6521
6522 if (hash_mode == 9710)
6523 {
6524 outfile_format = 5;
6525 outfile_format_chgd = 1;
6526 }
6527
6528 if (hash_mode == 9810)
6529 {
6530 outfile_format = 5;
6531 outfile_format_chgd = 1;
6532 }
6533
6534 if (hash_mode == 10410)
6535 {
6536 outfile_format = 5;
6537 outfile_format_chgd = 1;
6538 }
6539
6540 /**
6541 * store stuff
6542 */
6543
6544 data.hash_mode = hash_mode;
6545 data.restore = restore;
6546 data.restore_timer = restore_timer;
6547 data.restore_disable = restore_disable;
6548 data.status = status;
6549 data.status_timer = status_timer;
6550 data.status_automat = status_automat;
6551 data.loopback = loopback;
6552 data.runtime = runtime;
6553 data.remove = remove;
6554 data.remove_timer = remove_timer;
6555 data.debug_mode = debug_mode;
6556 data.debug_file = debug_file;
6557 data.username = username;
6558 data.quiet = quiet;
6559 data.outfile = outfile;
6560 data.outfile_format = outfile_format;
6561 data.outfile_autohex = outfile_autohex;
6562 data.hex_charset = hex_charset;
6563 data.hex_salt = hex_salt;
6564 data.hex_wordlist = hex_wordlist;
6565 data.separator = separator;
6566 data.rp_files = rp_files;
6567 data.rp_files_cnt = rp_files_cnt;
6568 data.rp_gen = rp_gen;
6569 data.rp_gen_seed = rp_gen_seed;
6570 data.force = force;
6571 data.benchmark = benchmark;
6572 data.benchmark_repeats = benchmark_repeats;
6573 data.skip = skip;
6574 data.limit = limit;
6575 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6576 data.powertune_enable = powertune_enable;
6577 #endif
6578 data.logfile_disable = logfile_disable;
6579 data.truecrypt_keyfiles = truecrypt_keyfiles;
6580 data.scrypt_tmto = scrypt_tmto;
6581 data.workload_profile = workload_profile;
6582
6583 /**
6584 * cpu affinity
6585 */
6586
6587 if (cpu_affinity)
6588 {
6589 set_cpu_affinity (cpu_affinity);
6590 }
6591
6592 if (rp_gen_seed_chgd == 0)
6593 {
6594 srand (proc_start);
6595 }
6596 else
6597 {
6598 srand (rp_gen_seed);
6599 }
6600
6601 /**
6602 * logfile init
6603 */
6604
6605 if (logfile_disable == 0)
6606 {
6607 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6608
6609 char *logfile = (char *) mymalloc (logfile_size);
6610
6611 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6612
6613 data.logfile = logfile;
6614
6615 char *topid = logfile_generate_topid ();
6616
6617 data.topid = topid;
6618 }
6619
6620 // logfile_append() checks for logfile_disable internally to make it easier from here
6621
6622 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6623 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6624 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6625 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6626 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6627 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6628 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6629 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6630 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6631 #define logfile_sub_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s\t%s", data.topid, data.subid, (var), (val));
6632
6633 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6634 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6635 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6636 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6637 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6638 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6639 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6640 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6641
6642 logfile_top_msg ("START");
6643
6644 logfile_top_uint (attack_mode);
6645 logfile_top_uint (attack_kern);
6646 logfile_top_uint (benchmark);
6647 logfile_top_uint (benchmark_repeats);
6648 logfile_top_uint (bitmap_min);
6649 logfile_top_uint (bitmap_max);
6650 logfile_top_uint (debug_mode);
6651 logfile_top_uint (force);
6652 logfile_top_uint (kernel_accel);
6653 logfile_top_uint (kernel_loops);
6654 logfile_top_uint (gpu_temp_disable);
6655 #ifdef HAVE_HWMON
6656 logfile_top_uint (gpu_temp_abort);
6657 logfile_top_uint (gpu_temp_retain);
6658 #endif
6659 logfile_top_uint (hash_mode);
6660 logfile_top_uint (hex_charset);
6661 logfile_top_uint (hex_salt);
6662 logfile_top_uint (hex_wordlist);
6663 logfile_top_uint (increment);
6664 logfile_top_uint (increment_max);
6665 logfile_top_uint (increment_min);
6666 logfile_top_uint (keyspace);
6667 logfile_top_uint (left);
6668 logfile_top_uint (logfile_disable);
6669 logfile_top_uint (loopback);
6670 logfile_top_uint (markov_classic);
6671 logfile_top_uint (markov_disable);
6672 logfile_top_uint (markov_threshold);
6673 logfile_top_uint (outfile_autohex);
6674 logfile_top_uint (outfile_check_timer);
6675 logfile_top_uint (outfile_format);
6676 logfile_top_uint (potfile_disable);
6677 logfile_top_string (potfile_path);
6678 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6679 logfile_top_uint (powertune_enable);
6680 #endif
6681 logfile_top_uint (scrypt_tmto);
6682 logfile_top_uint (quiet);
6683 logfile_top_uint (remove);
6684 logfile_top_uint (remove_timer);
6685 logfile_top_uint (restore);
6686 logfile_top_uint (restore_disable);
6687 logfile_top_uint (restore_timer);
6688 logfile_top_uint (rp_gen);
6689 logfile_top_uint (rp_gen_func_max);
6690 logfile_top_uint (rp_gen_func_min);
6691 logfile_top_uint (rp_gen_seed);
6692 logfile_top_uint (runtime);
6693 logfile_top_uint (segment_size);
6694 logfile_top_uint (show);
6695 logfile_top_uint (status);
6696 logfile_top_uint (status_automat);
6697 logfile_top_uint (status_timer);
6698 logfile_top_uint (usage);
6699 logfile_top_uint (username);
6700 logfile_top_uint (version);
6701 logfile_top_uint (weak_hash_threshold);
6702 logfile_top_uint (workload_profile);
6703 logfile_top_uint64 (limit);
6704 logfile_top_uint64 (skip);
6705 logfile_top_char (separator);
6706 logfile_top_string (cpu_affinity);
6707 logfile_top_string (custom_charset_1);
6708 logfile_top_string (custom_charset_2);
6709 logfile_top_string (custom_charset_3);
6710 logfile_top_string (custom_charset_4);
6711 logfile_top_string (debug_file);
6712 logfile_top_string (opencl_devices);
6713 logfile_top_string (opencl_platforms);
6714 logfile_top_string (opencl_device_types);
6715 logfile_top_uint (opencl_vector_width);
6716 logfile_top_string (induction_dir);
6717 logfile_top_string (markov_hcstat);
6718 logfile_top_string (outfile);
6719 logfile_top_string (outfile_check_dir);
6720 logfile_top_string (rule_buf_l);
6721 logfile_top_string (rule_buf_r);
6722 logfile_top_string (session);
6723 logfile_top_string (truecrypt_keyfiles);
6724
6725 /**
6726 * Init OpenCL library loader
6727 */
6728
6729 if (keyspace == 0)
6730 {
6731 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6732
6733 ocl_init (ocl);
6734
6735 data.ocl = ocl;
6736 }
6737
6738 /**
6739 * OpenCL platform selection
6740 */
6741
6742 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6743
6744 /**
6745 * OpenCL device selection
6746 */
6747
6748 u32 devices_filter = setup_devices_filter (opencl_devices);
6749
6750 /**
6751 * OpenCL device type selection
6752 */
6753
6754 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6755
6756 /**
6757 * benchmark
6758 */
6759
6760 if (benchmark == 1)
6761 {
6762 /**
6763 * disable useless stuff for benchmark
6764 */
6765
6766 status_timer = 0;
6767 restore_timer = 0;
6768 restore_disable = 1;
6769 potfile_disable = 1;
6770 weak_hash_threshold = 0;
6771 gpu_temp_disable = 1;
6772
6773 data.status_timer = status_timer;
6774 data.restore_timer = restore_timer;
6775 data.restore_disable = restore_disable;
6776
6777 /**
6778 * force attack mode to be bruteforce
6779 */
6780
6781 attack_mode = ATTACK_MODE_BF;
6782 attack_kern = ATTACK_KERN_BF;
6783
6784 if (workload_profile_chgd == 0)
6785 {
6786 workload_profile = 3;
6787
6788 data.workload_profile = workload_profile;
6789 }
6790 }
6791
6792 /**
6793 * config
6794 */
6795
6796 uint hash_type = 0;
6797 uint salt_type = 0;
6798 uint attack_exec = 0;
6799 uint opts_type = 0;
6800 uint kern_type = 0;
6801 uint dgst_size = 0;
6802 uint esalt_size = 0;
6803 uint opti_type = 0;
6804 uint dgst_pos0 = -1;
6805 uint dgst_pos1 = -1;
6806 uint dgst_pos2 = -1;
6807 uint dgst_pos3 = -1;
6808
6809 int (*parse_func) (char *, uint, hash_t *);
6810 int (*sort_by_digest) (const void *, const void *);
6811
6812 uint algorithm_pos = 0;
6813 uint algorithm_max = 1;
6814
6815 uint *algorithms = default_benchmark_algorithms;
6816
6817 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6818
6819 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6820 {
6821 /*
6822 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6823 * the following algos are skipped entirely
6824 */
6825
6826 if (algorithm_pos > 0)
6827 {
6828 local_free (rd);
6829
6830 rd = init_restore (argc, argv);
6831
6832 data.rd = rd;
6833 }
6834
6835 /**
6836 * update hash_mode in case of multihash benchmark
6837 */
6838
6839 if (benchmark == 1)
6840 {
6841 if (hash_mode_chgd == 0)
6842 {
6843 hash_mode = algorithms[algorithm_pos];
6844
6845 data.hash_mode = hash_mode;
6846 }
6847
6848 quiet = 1;
6849
6850 data.quiet = quiet;
6851 }
6852
6853 switch (hash_mode)
6854 {
6855 case 0: hash_type = HASH_TYPE_MD5;
6856 salt_type = SALT_TYPE_NONE;
6857 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6858 opts_type = OPTS_TYPE_PT_GENERATE_LE
6859 | OPTS_TYPE_PT_ADD80
6860 | OPTS_TYPE_PT_ADDBITS14;
6861 kern_type = KERN_TYPE_MD5;
6862 dgst_size = DGST_SIZE_4_4;
6863 parse_func = md5_parse_hash;
6864 sort_by_digest = sort_by_digest_4_4;
6865 opti_type = OPTI_TYPE_ZERO_BYTE
6866 | OPTI_TYPE_PRECOMPUTE_INIT
6867 | OPTI_TYPE_PRECOMPUTE_MERKLE
6868 | OPTI_TYPE_MEET_IN_MIDDLE
6869 | OPTI_TYPE_EARLY_SKIP
6870 | OPTI_TYPE_NOT_ITERATED
6871 | OPTI_TYPE_NOT_SALTED
6872 | OPTI_TYPE_RAW_HASH;
6873 dgst_pos0 = 0;
6874 dgst_pos1 = 3;
6875 dgst_pos2 = 2;
6876 dgst_pos3 = 1;
6877 break;
6878
6879 case 10: hash_type = HASH_TYPE_MD5;
6880 salt_type = SALT_TYPE_INTERN;
6881 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6882 opts_type = OPTS_TYPE_PT_GENERATE_LE
6883 | OPTS_TYPE_ST_ADD80
6884 | OPTS_TYPE_ST_ADDBITS14;
6885 kern_type = KERN_TYPE_MD5_PWSLT;
6886 dgst_size = DGST_SIZE_4_4;
6887 parse_func = md5s_parse_hash;
6888 sort_by_digest = sort_by_digest_4_4;
6889 opti_type = OPTI_TYPE_ZERO_BYTE
6890 | OPTI_TYPE_PRECOMPUTE_INIT
6891 | OPTI_TYPE_PRECOMPUTE_MERKLE
6892 | OPTI_TYPE_MEET_IN_MIDDLE
6893 | OPTI_TYPE_EARLY_SKIP
6894 | OPTI_TYPE_NOT_ITERATED
6895 | OPTI_TYPE_APPENDED_SALT
6896 | OPTI_TYPE_RAW_HASH;
6897 dgst_pos0 = 0;
6898 dgst_pos1 = 3;
6899 dgst_pos2 = 2;
6900 dgst_pos3 = 1;
6901 break;
6902
6903 case 11: hash_type = HASH_TYPE_MD5;
6904 salt_type = SALT_TYPE_INTERN;
6905 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6906 opts_type = OPTS_TYPE_PT_GENERATE_LE
6907 | OPTS_TYPE_ST_ADD80
6908 | OPTS_TYPE_ST_ADDBITS14;
6909 kern_type = KERN_TYPE_MD5_PWSLT;
6910 dgst_size = DGST_SIZE_4_4;
6911 parse_func = joomla_parse_hash;
6912 sort_by_digest = sort_by_digest_4_4;
6913 opti_type = OPTI_TYPE_ZERO_BYTE
6914 | OPTI_TYPE_PRECOMPUTE_INIT
6915 | OPTI_TYPE_PRECOMPUTE_MERKLE
6916 | OPTI_TYPE_MEET_IN_MIDDLE
6917 | OPTI_TYPE_EARLY_SKIP
6918 | OPTI_TYPE_NOT_ITERATED
6919 | OPTI_TYPE_APPENDED_SALT
6920 | OPTI_TYPE_RAW_HASH;
6921 dgst_pos0 = 0;
6922 dgst_pos1 = 3;
6923 dgst_pos2 = 2;
6924 dgst_pos3 = 1;
6925 break;
6926
6927 case 12: hash_type = HASH_TYPE_MD5;
6928 salt_type = SALT_TYPE_INTERN;
6929 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6930 opts_type = OPTS_TYPE_PT_GENERATE_LE
6931 | OPTS_TYPE_ST_ADD80
6932 | OPTS_TYPE_ST_ADDBITS14;
6933 kern_type = KERN_TYPE_MD5_PWSLT;
6934 dgst_size = DGST_SIZE_4_4;
6935 parse_func = postgresql_parse_hash;
6936 sort_by_digest = sort_by_digest_4_4;
6937 opti_type = OPTI_TYPE_ZERO_BYTE
6938 | OPTI_TYPE_PRECOMPUTE_INIT
6939 | OPTI_TYPE_PRECOMPUTE_MERKLE
6940 | OPTI_TYPE_MEET_IN_MIDDLE
6941 | OPTI_TYPE_EARLY_SKIP
6942 | OPTI_TYPE_NOT_ITERATED
6943 | OPTI_TYPE_APPENDED_SALT
6944 | OPTI_TYPE_RAW_HASH;
6945 dgst_pos0 = 0;
6946 dgst_pos1 = 3;
6947 dgst_pos2 = 2;
6948 dgst_pos3 = 1;
6949 break;
6950
6951 case 20: hash_type = HASH_TYPE_MD5;
6952 salt_type = SALT_TYPE_INTERN;
6953 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6954 opts_type = OPTS_TYPE_PT_GENERATE_LE
6955 | OPTS_TYPE_PT_ADD80
6956 | OPTS_TYPE_PT_ADDBITS14;
6957 kern_type = KERN_TYPE_MD5_SLTPW;
6958 dgst_size = DGST_SIZE_4_4;
6959 parse_func = md5s_parse_hash;
6960 sort_by_digest = sort_by_digest_4_4;
6961 opti_type = OPTI_TYPE_ZERO_BYTE
6962 | OPTI_TYPE_PRECOMPUTE_INIT
6963 | OPTI_TYPE_PRECOMPUTE_MERKLE
6964 | OPTI_TYPE_EARLY_SKIP
6965 | OPTI_TYPE_NOT_ITERATED
6966 | OPTI_TYPE_PREPENDED_SALT
6967 | OPTI_TYPE_RAW_HASH;
6968 dgst_pos0 = 0;
6969 dgst_pos1 = 3;
6970 dgst_pos2 = 2;
6971 dgst_pos3 = 1;
6972 break;
6973
6974 case 21: hash_type = HASH_TYPE_MD5;
6975 salt_type = SALT_TYPE_INTERN;
6976 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6977 opts_type = OPTS_TYPE_PT_GENERATE_LE
6978 | OPTS_TYPE_PT_ADD80
6979 | OPTS_TYPE_PT_ADDBITS14;
6980 kern_type = KERN_TYPE_MD5_SLTPW;
6981 dgst_size = DGST_SIZE_4_4;
6982 parse_func = osc_parse_hash;
6983 sort_by_digest = sort_by_digest_4_4;
6984 opti_type = OPTI_TYPE_ZERO_BYTE
6985 | OPTI_TYPE_PRECOMPUTE_INIT
6986 | OPTI_TYPE_PRECOMPUTE_MERKLE
6987 | OPTI_TYPE_EARLY_SKIP
6988 | OPTI_TYPE_NOT_ITERATED
6989 | OPTI_TYPE_PREPENDED_SALT
6990 | OPTI_TYPE_RAW_HASH;
6991 dgst_pos0 = 0;
6992 dgst_pos1 = 3;
6993 dgst_pos2 = 2;
6994 dgst_pos3 = 1;
6995 break;
6996
6997 case 22: hash_type = HASH_TYPE_MD5;
6998 salt_type = SALT_TYPE_EMBEDDED;
6999 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7000 opts_type = OPTS_TYPE_PT_GENERATE_LE
7001 | OPTS_TYPE_PT_ADD80
7002 | OPTS_TYPE_PT_ADDBITS14;
7003 kern_type = KERN_TYPE_MD5_SLTPW;
7004 dgst_size = DGST_SIZE_4_4;
7005 parse_func = netscreen_parse_hash;
7006 sort_by_digest = sort_by_digest_4_4;
7007 opti_type = OPTI_TYPE_ZERO_BYTE
7008 | OPTI_TYPE_PRECOMPUTE_INIT
7009 | OPTI_TYPE_PRECOMPUTE_MERKLE
7010 | OPTI_TYPE_EARLY_SKIP
7011 | OPTI_TYPE_NOT_ITERATED
7012 | OPTI_TYPE_PREPENDED_SALT
7013 | OPTI_TYPE_RAW_HASH;
7014 dgst_pos0 = 0;
7015 dgst_pos1 = 3;
7016 dgst_pos2 = 2;
7017 dgst_pos3 = 1;
7018 break;
7019
7020 case 23: hash_type = HASH_TYPE_MD5;
7021 salt_type = SALT_TYPE_EMBEDDED;
7022 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7023 opts_type = OPTS_TYPE_PT_GENERATE_LE
7024 | OPTS_TYPE_PT_ADD80
7025 | OPTS_TYPE_PT_ADDBITS14;
7026 kern_type = KERN_TYPE_MD5_SLTPW;
7027 dgst_size = DGST_SIZE_4_4;
7028 parse_func = skype_parse_hash;
7029 sort_by_digest = sort_by_digest_4_4;
7030 opti_type = OPTI_TYPE_ZERO_BYTE
7031 | OPTI_TYPE_PRECOMPUTE_INIT
7032 | OPTI_TYPE_PRECOMPUTE_MERKLE
7033 | OPTI_TYPE_EARLY_SKIP
7034 | OPTI_TYPE_NOT_ITERATED
7035 | OPTI_TYPE_PREPENDED_SALT
7036 | OPTI_TYPE_RAW_HASH;
7037 dgst_pos0 = 0;
7038 dgst_pos1 = 3;
7039 dgst_pos2 = 2;
7040 dgst_pos3 = 1;
7041 break;
7042
7043 case 30: hash_type = HASH_TYPE_MD5;
7044 salt_type = SALT_TYPE_INTERN;
7045 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7046 opts_type = OPTS_TYPE_PT_GENERATE_LE
7047 | OPTS_TYPE_PT_UNICODE
7048 | OPTS_TYPE_ST_ADD80
7049 | OPTS_TYPE_ST_ADDBITS14;
7050 kern_type = KERN_TYPE_MD5_PWUSLT;
7051 dgst_size = DGST_SIZE_4_4;
7052 parse_func = md5s_parse_hash;
7053 sort_by_digest = sort_by_digest_4_4;
7054 opti_type = OPTI_TYPE_ZERO_BYTE
7055 | OPTI_TYPE_PRECOMPUTE_INIT
7056 | OPTI_TYPE_PRECOMPUTE_MERKLE
7057 | OPTI_TYPE_MEET_IN_MIDDLE
7058 | OPTI_TYPE_EARLY_SKIP
7059 | OPTI_TYPE_NOT_ITERATED
7060 | OPTI_TYPE_APPENDED_SALT
7061 | OPTI_TYPE_RAW_HASH;
7062 dgst_pos0 = 0;
7063 dgst_pos1 = 3;
7064 dgst_pos2 = 2;
7065 dgst_pos3 = 1;
7066 break;
7067
7068 case 40: hash_type = HASH_TYPE_MD5;
7069 salt_type = SALT_TYPE_INTERN;
7070 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7071 opts_type = OPTS_TYPE_PT_GENERATE_LE
7072 | OPTS_TYPE_PT_ADD80
7073 | OPTS_TYPE_PT_ADDBITS14
7074 | OPTS_TYPE_PT_UNICODE;
7075 kern_type = KERN_TYPE_MD5_SLTPWU;
7076 dgst_size = DGST_SIZE_4_4;
7077 parse_func = md5s_parse_hash;
7078 sort_by_digest = sort_by_digest_4_4;
7079 opti_type = OPTI_TYPE_ZERO_BYTE
7080 | OPTI_TYPE_PRECOMPUTE_INIT
7081 | OPTI_TYPE_PRECOMPUTE_MERKLE
7082 | OPTI_TYPE_EARLY_SKIP
7083 | OPTI_TYPE_NOT_ITERATED
7084 | OPTI_TYPE_PREPENDED_SALT
7085 | OPTI_TYPE_RAW_HASH;
7086 dgst_pos0 = 0;
7087 dgst_pos1 = 3;
7088 dgst_pos2 = 2;
7089 dgst_pos3 = 1;
7090 break;
7091
7092 case 50: hash_type = HASH_TYPE_MD5;
7093 salt_type = SALT_TYPE_INTERN;
7094 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7095 opts_type = OPTS_TYPE_PT_GENERATE_LE
7096 | OPTS_TYPE_ST_ADD80
7097 | OPTS_TYPE_ST_ADDBITS14;
7098 kern_type = KERN_TYPE_HMACMD5_PW;
7099 dgst_size = DGST_SIZE_4_4;
7100 parse_func = hmacmd5_parse_hash;
7101 sort_by_digest = sort_by_digest_4_4;
7102 opti_type = OPTI_TYPE_ZERO_BYTE
7103 | OPTI_TYPE_NOT_ITERATED;
7104 dgst_pos0 = 0;
7105 dgst_pos1 = 3;
7106 dgst_pos2 = 2;
7107 dgst_pos3 = 1;
7108 break;
7109
7110 case 60: hash_type = HASH_TYPE_MD5;
7111 salt_type = SALT_TYPE_INTERN;
7112 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7113 opts_type = OPTS_TYPE_PT_GENERATE_LE
7114 | OPTS_TYPE_PT_ADD80
7115 | OPTS_TYPE_PT_ADDBITS14;
7116 kern_type = KERN_TYPE_HMACMD5_SLT;
7117 dgst_size = DGST_SIZE_4_4;
7118 parse_func = hmacmd5_parse_hash;
7119 sort_by_digest = sort_by_digest_4_4;
7120 opti_type = OPTI_TYPE_ZERO_BYTE
7121 | OPTI_TYPE_NOT_ITERATED;
7122 dgst_pos0 = 0;
7123 dgst_pos1 = 3;
7124 dgst_pos2 = 2;
7125 dgst_pos3 = 1;
7126 break;
7127
7128 case 100: hash_type = HASH_TYPE_SHA1;
7129 salt_type = SALT_TYPE_NONE;
7130 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7131 opts_type = OPTS_TYPE_PT_GENERATE_BE
7132 | OPTS_TYPE_PT_ADD80
7133 | OPTS_TYPE_PT_ADDBITS15;
7134 kern_type = KERN_TYPE_SHA1;
7135 dgst_size = DGST_SIZE_4_5;
7136 parse_func = sha1_parse_hash;
7137 sort_by_digest = sort_by_digest_4_5;
7138 opti_type = OPTI_TYPE_ZERO_BYTE
7139 | OPTI_TYPE_PRECOMPUTE_INIT
7140 | OPTI_TYPE_PRECOMPUTE_MERKLE
7141 | OPTI_TYPE_EARLY_SKIP
7142 | OPTI_TYPE_NOT_ITERATED
7143 | OPTI_TYPE_NOT_SALTED
7144 | OPTI_TYPE_RAW_HASH;
7145 dgst_pos0 = 3;
7146 dgst_pos1 = 4;
7147 dgst_pos2 = 2;
7148 dgst_pos3 = 1;
7149 break;
7150
7151 case 101: hash_type = HASH_TYPE_SHA1;
7152 salt_type = SALT_TYPE_NONE;
7153 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7154 opts_type = OPTS_TYPE_PT_GENERATE_BE
7155 | OPTS_TYPE_PT_ADD80
7156 | OPTS_TYPE_PT_ADDBITS15;
7157 kern_type = KERN_TYPE_SHA1;
7158 dgst_size = DGST_SIZE_4_5;
7159 parse_func = sha1b64_parse_hash;
7160 sort_by_digest = sort_by_digest_4_5;
7161 opti_type = OPTI_TYPE_ZERO_BYTE
7162 | OPTI_TYPE_PRECOMPUTE_INIT
7163 | OPTI_TYPE_PRECOMPUTE_MERKLE
7164 | OPTI_TYPE_EARLY_SKIP
7165 | OPTI_TYPE_NOT_ITERATED
7166 | OPTI_TYPE_NOT_SALTED
7167 | OPTI_TYPE_RAW_HASH;
7168 dgst_pos0 = 3;
7169 dgst_pos1 = 4;
7170 dgst_pos2 = 2;
7171 dgst_pos3 = 1;
7172 break;
7173
7174 case 110: hash_type = HASH_TYPE_SHA1;
7175 salt_type = SALT_TYPE_INTERN;
7176 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7177 opts_type = OPTS_TYPE_PT_GENERATE_BE
7178 | OPTS_TYPE_ST_ADD80
7179 | OPTS_TYPE_ST_ADDBITS15;
7180 kern_type = KERN_TYPE_SHA1_PWSLT;
7181 dgst_size = DGST_SIZE_4_5;
7182 parse_func = sha1s_parse_hash;
7183 sort_by_digest = sort_by_digest_4_5;
7184 opti_type = OPTI_TYPE_ZERO_BYTE
7185 | OPTI_TYPE_PRECOMPUTE_INIT
7186 | OPTI_TYPE_PRECOMPUTE_MERKLE
7187 | OPTI_TYPE_EARLY_SKIP
7188 | OPTI_TYPE_NOT_ITERATED
7189 | OPTI_TYPE_APPENDED_SALT
7190 | OPTI_TYPE_RAW_HASH;
7191 dgst_pos0 = 3;
7192 dgst_pos1 = 4;
7193 dgst_pos2 = 2;
7194 dgst_pos3 = 1;
7195 break;
7196
7197 case 111: hash_type = HASH_TYPE_SHA1;
7198 salt_type = SALT_TYPE_EMBEDDED;
7199 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7200 opts_type = OPTS_TYPE_PT_GENERATE_BE
7201 | OPTS_TYPE_ST_ADD80
7202 | OPTS_TYPE_ST_ADDBITS15;
7203 kern_type = KERN_TYPE_SHA1_PWSLT;
7204 dgst_size = DGST_SIZE_4_5;
7205 parse_func = sha1b64s_parse_hash;
7206 sort_by_digest = sort_by_digest_4_5;
7207 opti_type = OPTI_TYPE_ZERO_BYTE
7208 | OPTI_TYPE_PRECOMPUTE_INIT
7209 | OPTI_TYPE_PRECOMPUTE_MERKLE
7210 | OPTI_TYPE_EARLY_SKIP
7211 | OPTI_TYPE_NOT_ITERATED
7212 | OPTI_TYPE_APPENDED_SALT
7213 | OPTI_TYPE_RAW_HASH;
7214 dgst_pos0 = 3;
7215 dgst_pos1 = 4;
7216 dgst_pos2 = 2;
7217 dgst_pos3 = 1;
7218 break;
7219
7220 case 112: hash_type = HASH_TYPE_SHA1;
7221 salt_type = SALT_TYPE_INTERN;
7222 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7223 opts_type = OPTS_TYPE_PT_GENERATE_BE
7224 | OPTS_TYPE_ST_ADD80
7225 | OPTS_TYPE_ST_ADDBITS15
7226 | OPTS_TYPE_ST_HEX;
7227 kern_type = KERN_TYPE_SHA1_PWSLT;
7228 dgst_size = DGST_SIZE_4_5;
7229 parse_func = oracles_parse_hash;
7230 sort_by_digest = sort_by_digest_4_5;
7231 opti_type = OPTI_TYPE_ZERO_BYTE
7232 | OPTI_TYPE_PRECOMPUTE_INIT
7233 | OPTI_TYPE_PRECOMPUTE_MERKLE
7234 | OPTI_TYPE_EARLY_SKIP
7235 | OPTI_TYPE_NOT_ITERATED
7236 | OPTI_TYPE_APPENDED_SALT
7237 | OPTI_TYPE_RAW_HASH;
7238 dgst_pos0 = 3;
7239 dgst_pos1 = 4;
7240 dgst_pos2 = 2;
7241 dgst_pos3 = 1;
7242 break;
7243
7244 case 120: hash_type = HASH_TYPE_SHA1;
7245 salt_type = SALT_TYPE_INTERN;
7246 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7247 opts_type = OPTS_TYPE_PT_GENERATE_BE
7248 | OPTS_TYPE_PT_ADD80
7249 | OPTS_TYPE_PT_ADDBITS15;
7250 kern_type = KERN_TYPE_SHA1_SLTPW;
7251 dgst_size = DGST_SIZE_4_5;
7252 parse_func = sha1s_parse_hash;
7253 sort_by_digest = sort_by_digest_4_5;
7254 opti_type = OPTI_TYPE_ZERO_BYTE
7255 | OPTI_TYPE_PRECOMPUTE_INIT
7256 | OPTI_TYPE_PRECOMPUTE_MERKLE
7257 | OPTI_TYPE_EARLY_SKIP
7258 | OPTI_TYPE_NOT_ITERATED
7259 | OPTI_TYPE_PREPENDED_SALT
7260 | OPTI_TYPE_RAW_HASH;
7261 dgst_pos0 = 3;
7262 dgst_pos1 = 4;
7263 dgst_pos2 = 2;
7264 dgst_pos3 = 1;
7265 break;
7266
7267 case 121: hash_type = HASH_TYPE_SHA1;
7268 salt_type = SALT_TYPE_INTERN;
7269 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7270 opts_type = OPTS_TYPE_PT_GENERATE_BE
7271 | OPTS_TYPE_PT_ADD80
7272 | OPTS_TYPE_PT_ADDBITS15
7273 | OPTS_TYPE_ST_LOWER;
7274 kern_type = KERN_TYPE_SHA1_SLTPW;
7275 dgst_size = DGST_SIZE_4_5;
7276 parse_func = smf_parse_hash;
7277 sort_by_digest = sort_by_digest_4_5;
7278 opti_type = OPTI_TYPE_ZERO_BYTE
7279 | OPTI_TYPE_PRECOMPUTE_INIT
7280 | OPTI_TYPE_PRECOMPUTE_MERKLE
7281 | OPTI_TYPE_EARLY_SKIP
7282 | OPTI_TYPE_NOT_ITERATED
7283 | OPTI_TYPE_PREPENDED_SALT
7284 | OPTI_TYPE_RAW_HASH;
7285 dgst_pos0 = 3;
7286 dgst_pos1 = 4;
7287 dgst_pos2 = 2;
7288 dgst_pos3 = 1;
7289 break;
7290
7291 case 122: hash_type = HASH_TYPE_SHA1;
7292 salt_type = SALT_TYPE_EMBEDDED;
7293 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7294 opts_type = OPTS_TYPE_PT_GENERATE_BE
7295 | OPTS_TYPE_PT_ADD80
7296 | OPTS_TYPE_PT_ADDBITS15
7297 | OPTS_TYPE_ST_HEX;
7298 kern_type = KERN_TYPE_SHA1_SLTPW;
7299 dgst_size = DGST_SIZE_4_5;
7300 parse_func = osx1_parse_hash;
7301 sort_by_digest = sort_by_digest_4_5;
7302 opti_type = OPTI_TYPE_ZERO_BYTE
7303 | OPTI_TYPE_PRECOMPUTE_INIT
7304 | OPTI_TYPE_PRECOMPUTE_MERKLE
7305 | OPTI_TYPE_EARLY_SKIP
7306 | OPTI_TYPE_NOT_ITERATED
7307 | OPTI_TYPE_PREPENDED_SALT
7308 | OPTI_TYPE_RAW_HASH;
7309 dgst_pos0 = 3;
7310 dgst_pos1 = 4;
7311 dgst_pos2 = 2;
7312 dgst_pos3 = 1;
7313 break;
7314
7315 case 124: hash_type = HASH_TYPE_SHA1;
7316 salt_type = SALT_TYPE_EMBEDDED;
7317 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7318 opts_type = OPTS_TYPE_PT_GENERATE_BE
7319 | OPTS_TYPE_PT_ADD80
7320 | OPTS_TYPE_PT_ADDBITS15;
7321 kern_type = KERN_TYPE_SHA1_SLTPW;
7322 dgst_size = DGST_SIZE_4_5;
7323 parse_func = djangosha1_parse_hash;
7324 sort_by_digest = sort_by_digest_4_5;
7325 opti_type = OPTI_TYPE_ZERO_BYTE
7326 | OPTI_TYPE_PRECOMPUTE_INIT
7327 | OPTI_TYPE_PRECOMPUTE_MERKLE
7328 | OPTI_TYPE_EARLY_SKIP
7329 | OPTI_TYPE_NOT_ITERATED
7330 | OPTI_TYPE_PREPENDED_SALT
7331 | OPTI_TYPE_RAW_HASH;
7332 dgst_pos0 = 3;
7333 dgst_pos1 = 4;
7334 dgst_pos2 = 2;
7335 dgst_pos3 = 1;
7336 break;
7337
7338 case 125: hash_type = HASH_TYPE_SHA1;
7339 salt_type = SALT_TYPE_EMBEDDED;
7340 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7341 opts_type = OPTS_TYPE_PT_GENERATE_BE
7342 | OPTS_TYPE_PT_ADD80
7343 | OPTS_TYPE_PT_ADDBITS15
7344 | OPTS_TYPE_ST_HEX;
7345 kern_type = KERN_TYPE_SHA1_SLTPW;
7346 dgst_size = DGST_SIZE_4_5;
7347 parse_func = arubaos_parse_hash;
7348 sort_by_digest = sort_by_digest_4_5;
7349 opti_type = OPTI_TYPE_ZERO_BYTE
7350 | OPTI_TYPE_PRECOMPUTE_INIT
7351 | OPTI_TYPE_PRECOMPUTE_MERKLE
7352 | OPTI_TYPE_EARLY_SKIP
7353 | OPTI_TYPE_NOT_ITERATED
7354 | OPTI_TYPE_PREPENDED_SALT
7355 | OPTI_TYPE_RAW_HASH;
7356 dgst_pos0 = 3;
7357 dgst_pos1 = 4;
7358 dgst_pos2 = 2;
7359 dgst_pos3 = 1;
7360 break;
7361
7362 case 130: hash_type = HASH_TYPE_SHA1;
7363 salt_type = SALT_TYPE_INTERN;
7364 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7365 opts_type = OPTS_TYPE_PT_GENERATE_BE
7366 | OPTS_TYPE_PT_UNICODE
7367 | OPTS_TYPE_ST_ADD80
7368 | OPTS_TYPE_ST_ADDBITS15;
7369 kern_type = KERN_TYPE_SHA1_PWUSLT;
7370 dgst_size = DGST_SIZE_4_5;
7371 parse_func = sha1s_parse_hash;
7372 sort_by_digest = sort_by_digest_4_5;
7373 opti_type = OPTI_TYPE_ZERO_BYTE
7374 | OPTI_TYPE_PRECOMPUTE_INIT
7375 | OPTI_TYPE_PRECOMPUTE_MERKLE
7376 | OPTI_TYPE_EARLY_SKIP
7377 | OPTI_TYPE_NOT_ITERATED
7378 | OPTI_TYPE_APPENDED_SALT
7379 | OPTI_TYPE_RAW_HASH;
7380 dgst_pos0 = 3;
7381 dgst_pos1 = 4;
7382 dgst_pos2 = 2;
7383 dgst_pos3 = 1;
7384 break;
7385
7386 case 131: hash_type = HASH_TYPE_SHA1;
7387 salt_type = SALT_TYPE_EMBEDDED;
7388 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7389 opts_type = OPTS_TYPE_PT_GENERATE_BE
7390 | OPTS_TYPE_PT_UNICODE
7391 | OPTS_TYPE_PT_UPPER
7392 | OPTS_TYPE_ST_ADD80
7393 | OPTS_TYPE_ST_ADDBITS15
7394 | OPTS_TYPE_ST_HEX;
7395 kern_type = KERN_TYPE_SHA1_PWUSLT;
7396 dgst_size = DGST_SIZE_4_5;
7397 parse_func = mssql2000_parse_hash;
7398 sort_by_digest = sort_by_digest_4_5;
7399 opti_type = OPTI_TYPE_ZERO_BYTE
7400 | OPTI_TYPE_PRECOMPUTE_INIT
7401 | OPTI_TYPE_PRECOMPUTE_MERKLE
7402 | OPTI_TYPE_EARLY_SKIP
7403 | OPTI_TYPE_NOT_ITERATED
7404 | OPTI_TYPE_APPENDED_SALT
7405 | OPTI_TYPE_RAW_HASH;
7406 dgst_pos0 = 3;
7407 dgst_pos1 = 4;
7408 dgst_pos2 = 2;
7409 dgst_pos3 = 1;
7410 break;
7411
7412 case 132: hash_type = HASH_TYPE_SHA1;
7413 salt_type = SALT_TYPE_EMBEDDED;
7414 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7415 opts_type = OPTS_TYPE_PT_GENERATE_BE
7416 | OPTS_TYPE_PT_UNICODE
7417 | OPTS_TYPE_ST_ADD80
7418 | OPTS_TYPE_ST_ADDBITS15
7419 | OPTS_TYPE_ST_HEX;
7420 kern_type = KERN_TYPE_SHA1_PWUSLT;
7421 dgst_size = DGST_SIZE_4_5;
7422 parse_func = mssql2005_parse_hash;
7423 sort_by_digest = sort_by_digest_4_5;
7424 opti_type = OPTI_TYPE_ZERO_BYTE
7425 | OPTI_TYPE_PRECOMPUTE_INIT
7426 | OPTI_TYPE_PRECOMPUTE_MERKLE
7427 | OPTI_TYPE_EARLY_SKIP
7428 | OPTI_TYPE_NOT_ITERATED
7429 | OPTI_TYPE_APPENDED_SALT
7430 | OPTI_TYPE_RAW_HASH;
7431 dgst_pos0 = 3;
7432 dgst_pos1 = 4;
7433 dgst_pos2 = 2;
7434 dgst_pos3 = 1;
7435 break;
7436
7437 case 133: hash_type = HASH_TYPE_SHA1;
7438 salt_type = SALT_TYPE_EMBEDDED;
7439 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7440 opts_type = OPTS_TYPE_PT_GENERATE_BE
7441 | OPTS_TYPE_PT_UNICODE
7442 | OPTS_TYPE_ST_ADD80
7443 | OPTS_TYPE_ST_ADDBITS15;
7444 kern_type = KERN_TYPE_SHA1_PWUSLT;
7445 dgst_size = DGST_SIZE_4_5;
7446 parse_func = peoplesoft_parse_hash;
7447 sort_by_digest = sort_by_digest_4_5;
7448 opti_type = OPTI_TYPE_ZERO_BYTE
7449 | OPTI_TYPE_PRECOMPUTE_INIT
7450 | OPTI_TYPE_PRECOMPUTE_MERKLE
7451 | OPTI_TYPE_EARLY_SKIP
7452 | OPTI_TYPE_NOT_ITERATED
7453 | OPTI_TYPE_APPENDED_SALT
7454 | OPTI_TYPE_RAW_HASH;
7455 dgst_pos0 = 3;
7456 dgst_pos1 = 4;
7457 dgst_pos2 = 2;
7458 dgst_pos3 = 1;
7459 break;
7460
7461 case 140: hash_type = HASH_TYPE_SHA1;
7462 salt_type = SALT_TYPE_INTERN;
7463 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7464 opts_type = OPTS_TYPE_PT_GENERATE_BE
7465 | OPTS_TYPE_PT_ADD80
7466 | OPTS_TYPE_PT_ADDBITS15
7467 | OPTS_TYPE_PT_UNICODE;
7468 kern_type = KERN_TYPE_SHA1_SLTPWU;
7469 dgst_size = DGST_SIZE_4_5;
7470 parse_func = sha1s_parse_hash;
7471 sort_by_digest = sort_by_digest_4_5;
7472 opti_type = OPTI_TYPE_ZERO_BYTE
7473 | OPTI_TYPE_PRECOMPUTE_INIT
7474 | OPTI_TYPE_PRECOMPUTE_MERKLE
7475 | OPTI_TYPE_EARLY_SKIP
7476 | OPTI_TYPE_NOT_ITERATED
7477 | OPTI_TYPE_PREPENDED_SALT
7478 | OPTI_TYPE_RAW_HASH;
7479 dgst_pos0 = 3;
7480 dgst_pos1 = 4;
7481 dgst_pos2 = 2;
7482 dgst_pos3 = 1;
7483 break;
7484
7485 case 141: hash_type = HASH_TYPE_SHA1;
7486 salt_type = SALT_TYPE_EMBEDDED;
7487 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7488 opts_type = OPTS_TYPE_PT_GENERATE_BE
7489 | OPTS_TYPE_PT_ADD80
7490 | OPTS_TYPE_PT_ADDBITS15
7491 | OPTS_TYPE_PT_UNICODE
7492 | OPTS_TYPE_ST_BASE64;
7493 kern_type = KERN_TYPE_SHA1_SLTPWU;
7494 dgst_size = DGST_SIZE_4_5;
7495 parse_func = episerver_parse_hash;
7496 sort_by_digest = sort_by_digest_4_5;
7497 opti_type = OPTI_TYPE_ZERO_BYTE
7498 | OPTI_TYPE_PRECOMPUTE_INIT
7499 | OPTI_TYPE_PRECOMPUTE_MERKLE
7500 | OPTI_TYPE_EARLY_SKIP
7501 | OPTI_TYPE_NOT_ITERATED
7502 | OPTI_TYPE_PREPENDED_SALT
7503 | OPTI_TYPE_RAW_HASH;
7504 dgst_pos0 = 3;
7505 dgst_pos1 = 4;
7506 dgst_pos2 = 2;
7507 dgst_pos3 = 1;
7508 break;
7509
7510 case 150: hash_type = HASH_TYPE_SHA1;
7511 salt_type = SALT_TYPE_INTERN;
7512 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7513 opts_type = OPTS_TYPE_PT_GENERATE_BE
7514 | OPTS_TYPE_ST_ADD80
7515 | OPTS_TYPE_ST_ADDBITS15;
7516 kern_type = KERN_TYPE_HMACSHA1_PW;
7517 dgst_size = DGST_SIZE_4_5;
7518 parse_func = hmacsha1_parse_hash;
7519 sort_by_digest = sort_by_digest_4_5;
7520 opti_type = OPTI_TYPE_ZERO_BYTE
7521 | OPTI_TYPE_NOT_ITERATED;
7522 dgst_pos0 = 3;
7523 dgst_pos1 = 4;
7524 dgst_pos2 = 2;
7525 dgst_pos3 = 1;
7526 break;
7527
7528 case 160: hash_type = HASH_TYPE_SHA1;
7529 salt_type = SALT_TYPE_INTERN;
7530 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7531 opts_type = OPTS_TYPE_PT_GENERATE_BE
7532 | OPTS_TYPE_PT_ADD80
7533 | OPTS_TYPE_PT_ADDBITS15;
7534 kern_type = KERN_TYPE_HMACSHA1_SLT;
7535 dgst_size = DGST_SIZE_4_5;
7536 parse_func = hmacsha1_parse_hash;
7537 sort_by_digest = sort_by_digest_4_5;
7538 opti_type = OPTI_TYPE_ZERO_BYTE
7539 | OPTI_TYPE_NOT_ITERATED;
7540 dgst_pos0 = 3;
7541 dgst_pos1 = 4;
7542 dgst_pos2 = 2;
7543 dgst_pos3 = 1;
7544 break;
7545
7546 case 190: hash_type = HASH_TYPE_SHA1;
7547 salt_type = SALT_TYPE_NONE;
7548 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7549 opts_type = OPTS_TYPE_PT_GENERATE_BE
7550 | OPTS_TYPE_PT_ADD80
7551 | OPTS_TYPE_PT_ADDBITS15;
7552 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7553 dgst_size = DGST_SIZE_4_5;
7554 parse_func = sha1linkedin_parse_hash;
7555 sort_by_digest = sort_by_digest_4_5;
7556 opti_type = OPTI_TYPE_ZERO_BYTE
7557 | OPTI_TYPE_PRECOMPUTE_INIT
7558 | OPTI_TYPE_EARLY_SKIP
7559 | OPTI_TYPE_NOT_ITERATED
7560 | OPTI_TYPE_NOT_SALTED;
7561 dgst_pos0 = 0;
7562 dgst_pos1 = 4;
7563 dgst_pos2 = 3;
7564 dgst_pos3 = 2;
7565 break;
7566
7567 case 200: hash_type = HASH_TYPE_MYSQL;
7568 salt_type = SALT_TYPE_NONE;
7569 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7570 opts_type = 0;
7571 kern_type = KERN_TYPE_MYSQL;
7572 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7573 parse_func = mysql323_parse_hash;
7574 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7575 opti_type = OPTI_TYPE_ZERO_BYTE;
7576 dgst_pos0 = 0;
7577 dgst_pos1 = 1;
7578 dgst_pos2 = 2;
7579 dgst_pos3 = 3;
7580 break;
7581
7582 case 300: hash_type = HASH_TYPE_SHA1;
7583 salt_type = SALT_TYPE_NONE;
7584 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7585 opts_type = OPTS_TYPE_PT_GENERATE_BE
7586 | OPTS_TYPE_PT_ADD80
7587 | OPTS_TYPE_PT_ADDBITS15;
7588 kern_type = KERN_TYPE_MYSQL41;
7589 dgst_size = DGST_SIZE_4_5;
7590 parse_func = sha1_parse_hash;
7591 sort_by_digest = sort_by_digest_4_5;
7592 opti_type = OPTI_TYPE_ZERO_BYTE
7593 | OPTI_TYPE_PRECOMPUTE_INIT
7594 | OPTI_TYPE_PRECOMPUTE_MERKLE
7595 | OPTI_TYPE_EARLY_SKIP
7596 | OPTI_TYPE_NOT_ITERATED
7597 | OPTI_TYPE_NOT_SALTED;
7598 dgst_pos0 = 3;
7599 dgst_pos1 = 4;
7600 dgst_pos2 = 2;
7601 dgst_pos3 = 1;
7602 break;
7603
7604 case 400: hash_type = HASH_TYPE_MD5;
7605 salt_type = SALT_TYPE_EMBEDDED;
7606 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7607 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7608 kern_type = KERN_TYPE_PHPASS;
7609 dgst_size = DGST_SIZE_4_4;
7610 parse_func = phpass_parse_hash;
7611 sort_by_digest = sort_by_digest_4_4;
7612 opti_type = OPTI_TYPE_ZERO_BYTE;
7613 dgst_pos0 = 0;
7614 dgst_pos1 = 1;
7615 dgst_pos2 = 2;
7616 dgst_pos3 = 3;
7617 break;
7618
7619 case 500: hash_type = HASH_TYPE_MD5;
7620 salt_type = SALT_TYPE_EMBEDDED;
7621 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7622 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7623 kern_type = KERN_TYPE_MD5CRYPT;
7624 dgst_size = DGST_SIZE_4_4;
7625 parse_func = md5crypt_parse_hash;
7626 sort_by_digest = sort_by_digest_4_4;
7627 opti_type = OPTI_TYPE_ZERO_BYTE;
7628 dgst_pos0 = 0;
7629 dgst_pos1 = 1;
7630 dgst_pos2 = 2;
7631 dgst_pos3 = 3;
7632 break;
7633
7634 case 501: hash_type = HASH_TYPE_MD5;
7635 salt_type = SALT_TYPE_EMBEDDED;
7636 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7637 opts_type = OPTS_TYPE_PT_GENERATE_LE
7638 | OPTS_TYPE_HASH_COPY;
7639 kern_type = KERN_TYPE_MD5CRYPT;
7640 dgst_size = DGST_SIZE_4_4;
7641 parse_func = juniper_parse_hash;
7642 sort_by_digest = sort_by_digest_4_4;
7643 opti_type = OPTI_TYPE_ZERO_BYTE;
7644 dgst_pos0 = 0;
7645 dgst_pos1 = 1;
7646 dgst_pos2 = 2;
7647 dgst_pos3 = 3;
7648 break;
7649
7650 case 900: hash_type = HASH_TYPE_MD4;
7651 salt_type = SALT_TYPE_NONE;
7652 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7653 opts_type = OPTS_TYPE_PT_GENERATE_LE
7654 | OPTS_TYPE_PT_ADD80
7655 | OPTS_TYPE_PT_ADDBITS14;
7656 kern_type = KERN_TYPE_MD4;
7657 dgst_size = DGST_SIZE_4_4;
7658 parse_func = md4_parse_hash;
7659 sort_by_digest = sort_by_digest_4_4;
7660 opti_type = OPTI_TYPE_ZERO_BYTE
7661 | OPTI_TYPE_PRECOMPUTE_INIT
7662 | OPTI_TYPE_PRECOMPUTE_MERKLE
7663 | OPTI_TYPE_MEET_IN_MIDDLE
7664 | OPTI_TYPE_EARLY_SKIP
7665 | OPTI_TYPE_NOT_ITERATED
7666 | OPTI_TYPE_NOT_SALTED
7667 | OPTI_TYPE_RAW_HASH;
7668 dgst_pos0 = 0;
7669 dgst_pos1 = 3;
7670 dgst_pos2 = 2;
7671 dgst_pos3 = 1;
7672 break;
7673
7674 case 1000: hash_type = HASH_TYPE_MD4;
7675 salt_type = SALT_TYPE_NONE;
7676 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7677 opts_type = OPTS_TYPE_PT_GENERATE_LE
7678 | OPTS_TYPE_PT_ADD80
7679 | OPTS_TYPE_PT_ADDBITS14
7680 | OPTS_TYPE_PT_UNICODE;
7681 kern_type = KERN_TYPE_MD4_PWU;
7682 dgst_size = DGST_SIZE_4_4;
7683 parse_func = md4_parse_hash;
7684 sort_by_digest = sort_by_digest_4_4;
7685 opti_type = OPTI_TYPE_ZERO_BYTE
7686 | OPTI_TYPE_PRECOMPUTE_INIT
7687 | OPTI_TYPE_PRECOMPUTE_MERKLE
7688 | OPTI_TYPE_MEET_IN_MIDDLE
7689 | OPTI_TYPE_EARLY_SKIP
7690 | OPTI_TYPE_NOT_ITERATED
7691 | OPTI_TYPE_NOT_SALTED
7692 | OPTI_TYPE_RAW_HASH;
7693 dgst_pos0 = 0;
7694 dgst_pos1 = 3;
7695 dgst_pos2 = 2;
7696 dgst_pos3 = 1;
7697 break;
7698
7699 case 1100: hash_type = HASH_TYPE_MD4;
7700 salt_type = SALT_TYPE_INTERN;
7701 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7702 opts_type = OPTS_TYPE_PT_GENERATE_LE
7703 | OPTS_TYPE_PT_ADD80
7704 | OPTS_TYPE_PT_ADDBITS14
7705 | OPTS_TYPE_PT_UNICODE
7706 | OPTS_TYPE_ST_ADD80
7707 | OPTS_TYPE_ST_UNICODE
7708 | OPTS_TYPE_ST_LOWER;
7709 kern_type = KERN_TYPE_MD44_PWUSLT;
7710 dgst_size = DGST_SIZE_4_4;
7711 parse_func = dcc_parse_hash;
7712 sort_by_digest = sort_by_digest_4_4;
7713 opti_type = OPTI_TYPE_ZERO_BYTE
7714 | OPTI_TYPE_PRECOMPUTE_INIT
7715 | OPTI_TYPE_PRECOMPUTE_MERKLE
7716 | OPTI_TYPE_EARLY_SKIP
7717 | OPTI_TYPE_NOT_ITERATED;
7718 dgst_pos0 = 0;
7719 dgst_pos1 = 3;
7720 dgst_pos2 = 2;
7721 dgst_pos3 = 1;
7722 break;
7723
7724 case 1400: hash_type = HASH_TYPE_SHA256;
7725 salt_type = SALT_TYPE_NONE;
7726 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7727 opts_type = OPTS_TYPE_PT_GENERATE_BE
7728 | OPTS_TYPE_PT_ADD80
7729 | OPTS_TYPE_PT_ADDBITS15;
7730 kern_type = KERN_TYPE_SHA256;
7731 dgst_size = DGST_SIZE_4_8;
7732 parse_func = sha256_parse_hash;
7733 sort_by_digest = sort_by_digest_4_8;
7734 opti_type = OPTI_TYPE_ZERO_BYTE
7735 | OPTI_TYPE_PRECOMPUTE_INIT
7736 | OPTI_TYPE_PRECOMPUTE_MERKLE
7737 | OPTI_TYPE_EARLY_SKIP
7738 | OPTI_TYPE_NOT_ITERATED
7739 | OPTI_TYPE_NOT_SALTED
7740 | OPTI_TYPE_RAW_HASH;
7741 dgst_pos0 = 3;
7742 dgst_pos1 = 7;
7743 dgst_pos2 = 2;
7744 dgst_pos3 = 6;
7745 break;
7746
7747 case 1410: hash_type = HASH_TYPE_SHA256;
7748 salt_type = SALT_TYPE_INTERN;
7749 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7750 opts_type = OPTS_TYPE_PT_GENERATE_BE
7751 | OPTS_TYPE_ST_ADD80
7752 | OPTS_TYPE_ST_ADDBITS15;
7753 kern_type = KERN_TYPE_SHA256_PWSLT;
7754 dgst_size = DGST_SIZE_4_8;
7755 parse_func = sha256s_parse_hash;
7756 sort_by_digest = sort_by_digest_4_8;
7757 opti_type = OPTI_TYPE_ZERO_BYTE
7758 | OPTI_TYPE_PRECOMPUTE_INIT
7759 | OPTI_TYPE_PRECOMPUTE_MERKLE
7760 | OPTI_TYPE_EARLY_SKIP
7761 | OPTI_TYPE_NOT_ITERATED
7762 | OPTI_TYPE_APPENDED_SALT
7763 | OPTI_TYPE_RAW_HASH;
7764 dgst_pos0 = 3;
7765 dgst_pos1 = 7;
7766 dgst_pos2 = 2;
7767 dgst_pos3 = 6;
7768 break;
7769
7770 case 1420: hash_type = HASH_TYPE_SHA256;
7771 salt_type = SALT_TYPE_INTERN;
7772 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7773 opts_type = OPTS_TYPE_PT_GENERATE_BE
7774 | OPTS_TYPE_PT_ADD80
7775 | OPTS_TYPE_PT_ADDBITS15;
7776 kern_type = KERN_TYPE_SHA256_SLTPW;
7777 dgst_size = DGST_SIZE_4_8;
7778 parse_func = sha256s_parse_hash;
7779 sort_by_digest = sort_by_digest_4_8;
7780 opti_type = OPTI_TYPE_ZERO_BYTE
7781 | OPTI_TYPE_PRECOMPUTE_INIT
7782 | OPTI_TYPE_PRECOMPUTE_MERKLE
7783 | OPTI_TYPE_EARLY_SKIP
7784 | OPTI_TYPE_NOT_ITERATED
7785 | OPTI_TYPE_PREPENDED_SALT
7786 | OPTI_TYPE_RAW_HASH;
7787 dgst_pos0 = 3;
7788 dgst_pos1 = 7;
7789 dgst_pos2 = 2;
7790 dgst_pos3 = 6;
7791 break;
7792
7793 case 1421: hash_type = HASH_TYPE_SHA256;
7794 salt_type = SALT_TYPE_EMBEDDED;
7795 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7796 opts_type = OPTS_TYPE_PT_GENERATE_BE
7797 | OPTS_TYPE_PT_ADD80
7798 | OPTS_TYPE_PT_ADDBITS15;
7799 kern_type = KERN_TYPE_SHA256_SLTPW;
7800 dgst_size = DGST_SIZE_4_8;
7801 parse_func = hmailserver_parse_hash;
7802 sort_by_digest = sort_by_digest_4_8;
7803 opti_type = OPTI_TYPE_ZERO_BYTE
7804 | OPTI_TYPE_PRECOMPUTE_INIT
7805 | OPTI_TYPE_PRECOMPUTE_MERKLE
7806 | OPTI_TYPE_EARLY_SKIP
7807 | OPTI_TYPE_NOT_ITERATED
7808 | OPTI_TYPE_PREPENDED_SALT
7809 | OPTI_TYPE_RAW_HASH;
7810 dgst_pos0 = 3;
7811 dgst_pos1 = 7;
7812 dgst_pos2 = 2;
7813 dgst_pos3 = 6;
7814 break;
7815
7816 case 1430: hash_type = HASH_TYPE_SHA256;
7817 salt_type = SALT_TYPE_INTERN;
7818 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7819 opts_type = OPTS_TYPE_PT_GENERATE_BE
7820 | OPTS_TYPE_PT_UNICODE
7821 | OPTS_TYPE_ST_ADD80
7822 | OPTS_TYPE_ST_ADDBITS15;
7823 kern_type = KERN_TYPE_SHA256_PWUSLT;
7824 dgst_size = DGST_SIZE_4_8;
7825 parse_func = sha256s_parse_hash;
7826 sort_by_digest = sort_by_digest_4_8;
7827 opti_type = OPTI_TYPE_ZERO_BYTE
7828 | OPTI_TYPE_PRECOMPUTE_INIT
7829 | OPTI_TYPE_PRECOMPUTE_MERKLE
7830 | OPTI_TYPE_EARLY_SKIP
7831 | OPTI_TYPE_NOT_ITERATED
7832 | OPTI_TYPE_APPENDED_SALT
7833 | OPTI_TYPE_RAW_HASH;
7834 dgst_pos0 = 3;
7835 dgst_pos1 = 7;
7836 dgst_pos2 = 2;
7837 dgst_pos3 = 6;
7838 break;
7839
7840 case 1440: hash_type = HASH_TYPE_SHA256;
7841 salt_type = SALT_TYPE_INTERN;
7842 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7843 opts_type = OPTS_TYPE_PT_GENERATE_BE
7844 | OPTS_TYPE_PT_ADD80
7845 | OPTS_TYPE_PT_ADDBITS15
7846 | OPTS_TYPE_PT_UNICODE;
7847 kern_type = KERN_TYPE_SHA256_SLTPWU;
7848 dgst_size = DGST_SIZE_4_8;
7849 parse_func = sha256s_parse_hash;
7850 sort_by_digest = sort_by_digest_4_8;
7851 opti_type = OPTI_TYPE_ZERO_BYTE
7852 | OPTI_TYPE_PRECOMPUTE_INIT
7853 | OPTI_TYPE_PRECOMPUTE_MERKLE
7854 | OPTI_TYPE_EARLY_SKIP
7855 | OPTI_TYPE_NOT_ITERATED
7856 | OPTI_TYPE_PREPENDED_SALT
7857 | OPTI_TYPE_RAW_HASH;
7858 dgst_pos0 = 3;
7859 dgst_pos1 = 7;
7860 dgst_pos2 = 2;
7861 dgst_pos3 = 6;
7862 break;
7863
7864 case 1441: hash_type = HASH_TYPE_SHA256;
7865 salt_type = SALT_TYPE_EMBEDDED;
7866 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7867 opts_type = OPTS_TYPE_PT_GENERATE_BE
7868 | OPTS_TYPE_PT_ADD80
7869 | OPTS_TYPE_PT_ADDBITS15
7870 | OPTS_TYPE_PT_UNICODE
7871 | OPTS_TYPE_ST_BASE64;
7872 kern_type = KERN_TYPE_SHA256_SLTPWU;
7873 dgst_size = DGST_SIZE_4_8;
7874 parse_func = episerver4_parse_hash;
7875 sort_by_digest = sort_by_digest_4_8;
7876 opti_type = OPTI_TYPE_ZERO_BYTE
7877 | OPTI_TYPE_PRECOMPUTE_INIT
7878 | OPTI_TYPE_PRECOMPUTE_MERKLE
7879 | OPTI_TYPE_EARLY_SKIP
7880 | OPTI_TYPE_NOT_ITERATED
7881 | OPTI_TYPE_PREPENDED_SALT
7882 | OPTI_TYPE_RAW_HASH;
7883 dgst_pos0 = 3;
7884 dgst_pos1 = 7;
7885 dgst_pos2 = 2;
7886 dgst_pos3 = 6;
7887 break;
7888
7889 case 1450: hash_type = HASH_TYPE_SHA256;
7890 salt_type = SALT_TYPE_INTERN;
7891 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7892 opts_type = OPTS_TYPE_PT_GENERATE_BE
7893 | OPTS_TYPE_ST_ADD80;
7894 kern_type = KERN_TYPE_HMACSHA256_PW;
7895 dgst_size = DGST_SIZE_4_8;
7896 parse_func = hmacsha256_parse_hash;
7897 sort_by_digest = sort_by_digest_4_8;
7898 opti_type = OPTI_TYPE_ZERO_BYTE
7899 | OPTI_TYPE_NOT_ITERATED;
7900 dgst_pos0 = 3;
7901 dgst_pos1 = 7;
7902 dgst_pos2 = 2;
7903 dgst_pos3 = 6;
7904 break;
7905
7906 case 1460: hash_type = HASH_TYPE_SHA256;
7907 salt_type = SALT_TYPE_INTERN;
7908 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7909 opts_type = OPTS_TYPE_PT_GENERATE_BE
7910 | OPTS_TYPE_PT_ADD80
7911 | OPTS_TYPE_PT_ADDBITS15;
7912 kern_type = KERN_TYPE_HMACSHA256_SLT;
7913 dgst_size = DGST_SIZE_4_8;
7914 parse_func = hmacsha256_parse_hash;
7915 sort_by_digest = sort_by_digest_4_8;
7916 opti_type = OPTI_TYPE_ZERO_BYTE
7917 | OPTI_TYPE_NOT_ITERATED;
7918 dgst_pos0 = 3;
7919 dgst_pos1 = 7;
7920 dgst_pos2 = 2;
7921 dgst_pos3 = 6;
7922 break;
7923
7924 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7925 salt_type = SALT_TYPE_EMBEDDED;
7926 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7927 opts_type = OPTS_TYPE_PT_GENERATE_LE
7928 | OPTS_TYPE_PT_BITSLICE;
7929 kern_type = KERN_TYPE_DESCRYPT;
7930 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7931 parse_func = descrypt_parse_hash;
7932 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7933 opti_type = OPTI_TYPE_ZERO_BYTE
7934 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7935 dgst_pos0 = 0;
7936 dgst_pos1 = 1;
7937 dgst_pos2 = 2;
7938 dgst_pos3 = 3;
7939 break;
7940
7941 case 1600: hash_type = HASH_TYPE_MD5;
7942 salt_type = SALT_TYPE_EMBEDDED;
7943 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7944 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7945 kern_type = KERN_TYPE_APR1CRYPT;
7946 dgst_size = DGST_SIZE_4_4;
7947 parse_func = md5apr1_parse_hash;
7948 sort_by_digest = sort_by_digest_4_4;
7949 opti_type = OPTI_TYPE_ZERO_BYTE;
7950 dgst_pos0 = 0;
7951 dgst_pos1 = 1;
7952 dgst_pos2 = 2;
7953 dgst_pos3 = 3;
7954 break;
7955
7956 case 1700: hash_type = HASH_TYPE_SHA512;
7957 salt_type = SALT_TYPE_NONE;
7958 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7959 opts_type = OPTS_TYPE_PT_GENERATE_BE
7960 | OPTS_TYPE_PT_ADD80
7961 | OPTS_TYPE_PT_ADDBITS15;
7962 kern_type = KERN_TYPE_SHA512;
7963 dgst_size = DGST_SIZE_8_8;
7964 parse_func = sha512_parse_hash;
7965 sort_by_digest = sort_by_digest_8_8;
7966 opti_type = OPTI_TYPE_ZERO_BYTE
7967 | OPTI_TYPE_PRECOMPUTE_INIT
7968 | OPTI_TYPE_PRECOMPUTE_MERKLE
7969 | OPTI_TYPE_EARLY_SKIP
7970 | OPTI_TYPE_NOT_ITERATED
7971 | OPTI_TYPE_NOT_SALTED
7972 | OPTI_TYPE_USES_BITS_64
7973 | OPTI_TYPE_RAW_HASH;
7974 dgst_pos0 = 14;
7975 dgst_pos1 = 15;
7976 dgst_pos2 = 6;
7977 dgst_pos3 = 7;
7978 break;
7979
7980 case 1710: hash_type = HASH_TYPE_SHA512;
7981 salt_type = SALT_TYPE_INTERN;
7982 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7983 opts_type = OPTS_TYPE_PT_GENERATE_BE
7984 | OPTS_TYPE_ST_ADD80
7985 | OPTS_TYPE_ST_ADDBITS15;
7986 kern_type = KERN_TYPE_SHA512_PWSLT;
7987 dgst_size = DGST_SIZE_8_8;
7988 parse_func = sha512s_parse_hash;
7989 sort_by_digest = sort_by_digest_8_8;
7990 opti_type = OPTI_TYPE_ZERO_BYTE
7991 | OPTI_TYPE_PRECOMPUTE_INIT
7992 | OPTI_TYPE_PRECOMPUTE_MERKLE
7993 | OPTI_TYPE_EARLY_SKIP
7994 | OPTI_TYPE_NOT_ITERATED
7995 | OPTI_TYPE_APPENDED_SALT
7996 | OPTI_TYPE_USES_BITS_64
7997 | OPTI_TYPE_RAW_HASH;
7998 dgst_pos0 = 14;
7999 dgst_pos1 = 15;
8000 dgst_pos2 = 6;
8001 dgst_pos3 = 7;
8002 break;
8003
8004 case 1711: hash_type = HASH_TYPE_SHA512;
8005 salt_type = SALT_TYPE_EMBEDDED;
8006 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8007 opts_type = OPTS_TYPE_PT_GENERATE_BE
8008 | OPTS_TYPE_ST_ADD80
8009 | OPTS_TYPE_ST_ADDBITS15;
8010 kern_type = KERN_TYPE_SHA512_PWSLT;
8011 dgst_size = DGST_SIZE_8_8;
8012 parse_func = sha512b64s_parse_hash;
8013 sort_by_digest = sort_by_digest_8_8;
8014 opti_type = OPTI_TYPE_ZERO_BYTE
8015 | OPTI_TYPE_PRECOMPUTE_INIT
8016 | OPTI_TYPE_PRECOMPUTE_MERKLE
8017 | OPTI_TYPE_EARLY_SKIP
8018 | OPTI_TYPE_NOT_ITERATED
8019 | OPTI_TYPE_APPENDED_SALT
8020 | OPTI_TYPE_USES_BITS_64
8021 | OPTI_TYPE_RAW_HASH;
8022 dgst_pos0 = 14;
8023 dgst_pos1 = 15;
8024 dgst_pos2 = 6;
8025 dgst_pos3 = 7;
8026 break;
8027
8028 case 1720: hash_type = HASH_TYPE_SHA512;
8029 salt_type = SALT_TYPE_INTERN;
8030 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8031 opts_type = OPTS_TYPE_PT_GENERATE_BE
8032 | OPTS_TYPE_PT_ADD80
8033 | OPTS_TYPE_PT_ADDBITS15;
8034 kern_type = KERN_TYPE_SHA512_SLTPW;
8035 dgst_size = DGST_SIZE_8_8;
8036 parse_func = sha512s_parse_hash;
8037 sort_by_digest = sort_by_digest_8_8;
8038 opti_type = OPTI_TYPE_ZERO_BYTE
8039 | OPTI_TYPE_PRECOMPUTE_INIT
8040 | OPTI_TYPE_PRECOMPUTE_MERKLE
8041 | OPTI_TYPE_EARLY_SKIP
8042 | OPTI_TYPE_NOT_ITERATED
8043 | OPTI_TYPE_PREPENDED_SALT
8044 | OPTI_TYPE_USES_BITS_64
8045 | OPTI_TYPE_RAW_HASH;
8046 dgst_pos0 = 14;
8047 dgst_pos1 = 15;
8048 dgst_pos2 = 6;
8049 dgst_pos3 = 7;
8050 break;
8051
8052 case 1722: hash_type = HASH_TYPE_SHA512;
8053 salt_type = SALT_TYPE_EMBEDDED;
8054 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8055 opts_type = OPTS_TYPE_PT_GENERATE_BE
8056 | OPTS_TYPE_PT_ADD80
8057 | OPTS_TYPE_PT_ADDBITS15
8058 | OPTS_TYPE_ST_HEX;
8059 kern_type = KERN_TYPE_SHA512_SLTPW;
8060 dgst_size = DGST_SIZE_8_8;
8061 parse_func = osx512_parse_hash;
8062 sort_by_digest = sort_by_digest_8_8;
8063 opti_type = OPTI_TYPE_ZERO_BYTE
8064 | OPTI_TYPE_PRECOMPUTE_INIT
8065 | OPTI_TYPE_PRECOMPUTE_MERKLE
8066 | OPTI_TYPE_EARLY_SKIP
8067 | OPTI_TYPE_NOT_ITERATED
8068 | OPTI_TYPE_PREPENDED_SALT
8069 | OPTI_TYPE_USES_BITS_64
8070 | OPTI_TYPE_RAW_HASH;
8071 dgst_pos0 = 14;
8072 dgst_pos1 = 15;
8073 dgst_pos2 = 6;
8074 dgst_pos3 = 7;
8075 break;
8076
8077 case 1730: hash_type = HASH_TYPE_SHA512;
8078 salt_type = SALT_TYPE_INTERN;
8079 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8080 opts_type = OPTS_TYPE_PT_GENERATE_BE
8081 | OPTS_TYPE_PT_UNICODE
8082 | OPTS_TYPE_ST_ADD80
8083 | OPTS_TYPE_ST_ADDBITS15;
8084 kern_type = KERN_TYPE_SHA512_PWSLTU;
8085 dgst_size = DGST_SIZE_8_8;
8086 parse_func = sha512s_parse_hash;
8087 sort_by_digest = sort_by_digest_8_8;
8088 opti_type = OPTI_TYPE_ZERO_BYTE
8089 | OPTI_TYPE_PRECOMPUTE_INIT
8090 | OPTI_TYPE_PRECOMPUTE_MERKLE
8091 | OPTI_TYPE_EARLY_SKIP
8092 | OPTI_TYPE_NOT_ITERATED
8093 | OPTI_TYPE_APPENDED_SALT
8094 | OPTI_TYPE_USES_BITS_64
8095 | OPTI_TYPE_RAW_HASH;
8096 dgst_pos0 = 14;
8097 dgst_pos1 = 15;
8098 dgst_pos2 = 6;
8099 dgst_pos3 = 7;
8100 break;
8101
8102 case 1731: hash_type = HASH_TYPE_SHA512;
8103 salt_type = SALT_TYPE_EMBEDDED;
8104 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8105 opts_type = OPTS_TYPE_PT_GENERATE_BE
8106 | OPTS_TYPE_PT_UNICODE
8107 | OPTS_TYPE_ST_ADD80
8108 | OPTS_TYPE_ST_ADDBITS15
8109 | OPTS_TYPE_ST_HEX;
8110 kern_type = KERN_TYPE_SHA512_PWSLTU;
8111 dgst_size = DGST_SIZE_8_8;
8112 parse_func = mssql2012_parse_hash;
8113 sort_by_digest = sort_by_digest_8_8;
8114 opti_type = OPTI_TYPE_ZERO_BYTE
8115 | OPTI_TYPE_PRECOMPUTE_INIT
8116 | OPTI_TYPE_PRECOMPUTE_MERKLE
8117 | OPTI_TYPE_EARLY_SKIP
8118 | OPTI_TYPE_NOT_ITERATED
8119 | OPTI_TYPE_APPENDED_SALT
8120 | OPTI_TYPE_USES_BITS_64
8121 | OPTI_TYPE_RAW_HASH;
8122 dgst_pos0 = 14;
8123 dgst_pos1 = 15;
8124 dgst_pos2 = 6;
8125 dgst_pos3 = 7;
8126 break;
8127
8128 case 1740: hash_type = HASH_TYPE_SHA512;
8129 salt_type = SALT_TYPE_INTERN;
8130 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8131 opts_type = OPTS_TYPE_PT_GENERATE_BE
8132 | OPTS_TYPE_PT_ADD80
8133 | OPTS_TYPE_PT_ADDBITS15
8134 | OPTS_TYPE_PT_UNICODE;
8135 kern_type = KERN_TYPE_SHA512_SLTPWU;
8136 dgst_size = DGST_SIZE_8_8;
8137 parse_func = sha512s_parse_hash;
8138 sort_by_digest = sort_by_digest_8_8;
8139 opti_type = OPTI_TYPE_ZERO_BYTE
8140 | OPTI_TYPE_PRECOMPUTE_INIT
8141 | OPTI_TYPE_PRECOMPUTE_MERKLE
8142 | OPTI_TYPE_EARLY_SKIP
8143 | OPTI_TYPE_NOT_ITERATED
8144 | OPTI_TYPE_PREPENDED_SALT
8145 | OPTI_TYPE_USES_BITS_64
8146 | OPTI_TYPE_RAW_HASH;
8147 dgst_pos0 = 14;
8148 dgst_pos1 = 15;
8149 dgst_pos2 = 6;
8150 dgst_pos3 = 7;
8151 break;
8152
8153 case 1750: hash_type = HASH_TYPE_SHA512;
8154 salt_type = SALT_TYPE_INTERN;
8155 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8156 opts_type = OPTS_TYPE_PT_GENERATE_BE
8157 | OPTS_TYPE_ST_ADD80;
8158 kern_type = KERN_TYPE_HMACSHA512_PW;
8159 dgst_size = DGST_SIZE_8_8;
8160 parse_func = hmacsha512_parse_hash;
8161 sort_by_digest = sort_by_digest_8_8;
8162 opti_type = OPTI_TYPE_ZERO_BYTE
8163 | OPTI_TYPE_USES_BITS_64
8164 | OPTI_TYPE_NOT_ITERATED;
8165 dgst_pos0 = 14;
8166 dgst_pos1 = 15;
8167 dgst_pos2 = 6;
8168 dgst_pos3 = 7;
8169 break;
8170
8171 case 1760: hash_type = HASH_TYPE_SHA512;
8172 salt_type = SALT_TYPE_INTERN;
8173 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8174 opts_type = OPTS_TYPE_PT_GENERATE_BE
8175 | OPTS_TYPE_PT_ADD80
8176 | OPTS_TYPE_PT_ADDBITS15;
8177 kern_type = KERN_TYPE_HMACSHA512_SLT;
8178 dgst_size = DGST_SIZE_8_8;
8179 parse_func = hmacsha512_parse_hash;
8180 sort_by_digest = sort_by_digest_8_8;
8181 opti_type = OPTI_TYPE_ZERO_BYTE
8182 | OPTI_TYPE_USES_BITS_64
8183 | OPTI_TYPE_NOT_ITERATED;
8184 dgst_pos0 = 14;
8185 dgst_pos1 = 15;
8186 dgst_pos2 = 6;
8187 dgst_pos3 = 7;
8188 break;
8189
8190 case 1800: hash_type = HASH_TYPE_SHA512;
8191 salt_type = SALT_TYPE_EMBEDDED;
8192 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8193 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8194 kern_type = KERN_TYPE_SHA512CRYPT;
8195 dgst_size = DGST_SIZE_8_8;
8196 parse_func = sha512crypt_parse_hash;
8197 sort_by_digest = sort_by_digest_8_8;
8198 opti_type = OPTI_TYPE_ZERO_BYTE
8199 | OPTI_TYPE_USES_BITS_64;
8200 dgst_pos0 = 0;
8201 dgst_pos1 = 1;
8202 dgst_pos2 = 2;
8203 dgst_pos3 = 3;
8204 break;
8205
8206 case 2100: hash_type = HASH_TYPE_DCC2;
8207 salt_type = SALT_TYPE_EMBEDDED;
8208 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8209 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8210 | OPTS_TYPE_ST_LOWER
8211 | OPTS_TYPE_ST_UNICODE;
8212 kern_type = KERN_TYPE_DCC2;
8213 dgst_size = DGST_SIZE_4_4;
8214 parse_func = dcc2_parse_hash;
8215 sort_by_digest = sort_by_digest_4_4;
8216 opti_type = OPTI_TYPE_ZERO_BYTE;
8217 dgst_pos0 = 0;
8218 dgst_pos1 = 1;
8219 dgst_pos2 = 2;
8220 dgst_pos3 = 3;
8221 break;
8222
8223 case 2400: hash_type = HASH_TYPE_MD5;
8224 salt_type = SALT_TYPE_NONE;
8225 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8226 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8227 kern_type = KERN_TYPE_MD5PIX;
8228 dgst_size = DGST_SIZE_4_4;
8229 parse_func = md5pix_parse_hash;
8230 sort_by_digest = sort_by_digest_4_4;
8231 opti_type = OPTI_TYPE_ZERO_BYTE
8232 | OPTI_TYPE_PRECOMPUTE_INIT
8233 | OPTI_TYPE_PRECOMPUTE_MERKLE
8234 | OPTI_TYPE_EARLY_SKIP
8235 | OPTI_TYPE_NOT_ITERATED
8236 | OPTI_TYPE_NOT_SALTED;
8237 dgst_pos0 = 0;
8238 dgst_pos1 = 3;
8239 dgst_pos2 = 2;
8240 dgst_pos3 = 1;
8241 break;
8242
8243 case 2410: hash_type = HASH_TYPE_MD5;
8244 salt_type = SALT_TYPE_INTERN;
8245 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8246 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8247 kern_type = KERN_TYPE_MD5ASA;
8248 dgst_size = DGST_SIZE_4_4;
8249 parse_func = md5asa_parse_hash;
8250 sort_by_digest = sort_by_digest_4_4;
8251 opti_type = OPTI_TYPE_ZERO_BYTE
8252 | OPTI_TYPE_PRECOMPUTE_INIT
8253 | OPTI_TYPE_PRECOMPUTE_MERKLE
8254 | OPTI_TYPE_EARLY_SKIP
8255 | OPTI_TYPE_NOT_ITERATED;
8256 dgst_pos0 = 0;
8257 dgst_pos1 = 3;
8258 dgst_pos2 = 2;
8259 dgst_pos3 = 1;
8260 break;
8261
8262 case 2500: hash_type = HASH_TYPE_WPA;
8263 salt_type = SALT_TYPE_EMBEDDED;
8264 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8265 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8266 kern_type = KERN_TYPE_WPA;
8267 dgst_size = DGST_SIZE_4_4;
8268 parse_func = wpa_parse_hash;
8269 sort_by_digest = sort_by_digest_4_4;
8270 opti_type = OPTI_TYPE_ZERO_BYTE;
8271 dgst_pos0 = 0;
8272 dgst_pos1 = 1;
8273 dgst_pos2 = 2;
8274 dgst_pos3 = 3;
8275 break;
8276
8277 case 2600: hash_type = HASH_TYPE_MD5;
8278 salt_type = SALT_TYPE_VIRTUAL;
8279 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8280 opts_type = OPTS_TYPE_PT_GENERATE_LE
8281 | OPTS_TYPE_PT_ADD80
8282 | OPTS_TYPE_PT_ADDBITS14
8283 | OPTS_TYPE_ST_ADD80;
8284 kern_type = KERN_TYPE_MD55_PWSLT1;
8285 dgst_size = DGST_SIZE_4_4;
8286 parse_func = md5md5_parse_hash;
8287 sort_by_digest = sort_by_digest_4_4;
8288 opti_type = OPTI_TYPE_ZERO_BYTE
8289 | OPTI_TYPE_PRECOMPUTE_INIT
8290 | OPTI_TYPE_PRECOMPUTE_MERKLE
8291 | OPTI_TYPE_EARLY_SKIP;
8292 dgst_pos0 = 0;
8293 dgst_pos1 = 3;
8294 dgst_pos2 = 2;
8295 dgst_pos3 = 1;
8296 break;
8297
8298 case 2611: hash_type = HASH_TYPE_MD5;
8299 salt_type = SALT_TYPE_INTERN;
8300 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8301 opts_type = OPTS_TYPE_PT_GENERATE_LE
8302 | OPTS_TYPE_PT_ADD80
8303 | OPTS_TYPE_PT_ADDBITS14
8304 | OPTS_TYPE_ST_ADD80;
8305 kern_type = KERN_TYPE_MD55_PWSLT1;
8306 dgst_size = DGST_SIZE_4_4;
8307 parse_func = vb3_parse_hash;
8308 sort_by_digest = sort_by_digest_4_4;
8309 opti_type = OPTI_TYPE_ZERO_BYTE
8310 | OPTI_TYPE_PRECOMPUTE_INIT
8311 | OPTI_TYPE_PRECOMPUTE_MERKLE
8312 | OPTI_TYPE_EARLY_SKIP;
8313 dgst_pos0 = 0;
8314 dgst_pos1 = 3;
8315 dgst_pos2 = 2;
8316 dgst_pos3 = 1;
8317 break;
8318
8319 case 2612: hash_type = HASH_TYPE_MD5;
8320 salt_type = SALT_TYPE_EMBEDDED;
8321 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8322 opts_type = OPTS_TYPE_PT_GENERATE_LE
8323 | OPTS_TYPE_PT_ADD80
8324 | OPTS_TYPE_PT_ADDBITS14
8325 | OPTS_TYPE_ST_ADD80
8326 | OPTS_TYPE_ST_HEX;
8327 kern_type = KERN_TYPE_MD55_PWSLT1;
8328 dgst_size = DGST_SIZE_4_4;
8329 parse_func = phps_parse_hash;
8330 sort_by_digest = sort_by_digest_4_4;
8331 opti_type = OPTI_TYPE_ZERO_BYTE
8332 | OPTI_TYPE_PRECOMPUTE_INIT
8333 | OPTI_TYPE_PRECOMPUTE_MERKLE
8334 | OPTI_TYPE_EARLY_SKIP;
8335 dgst_pos0 = 0;
8336 dgst_pos1 = 3;
8337 dgst_pos2 = 2;
8338 dgst_pos3 = 1;
8339 break;
8340
8341 case 2711: hash_type = HASH_TYPE_MD5;
8342 salt_type = SALT_TYPE_INTERN;
8343 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8344 opts_type = OPTS_TYPE_PT_GENERATE_LE
8345 | OPTS_TYPE_PT_ADD80
8346 | OPTS_TYPE_PT_ADDBITS14
8347 | OPTS_TYPE_ST_ADD80;
8348 kern_type = KERN_TYPE_MD55_PWSLT2;
8349 dgst_size = DGST_SIZE_4_4;
8350 parse_func = vb30_parse_hash;
8351 sort_by_digest = sort_by_digest_4_4;
8352 opti_type = OPTI_TYPE_ZERO_BYTE
8353 | OPTI_TYPE_PRECOMPUTE_INIT
8354 | OPTI_TYPE_EARLY_SKIP;
8355 dgst_pos0 = 0;
8356 dgst_pos1 = 3;
8357 dgst_pos2 = 2;
8358 dgst_pos3 = 1;
8359 break;
8360
8361 case 2811: hash_type = HASH_TYPE_MD5;
8362 salt_type = SALT_TYPE_INTERN;
8363 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8364 opts_type = OPTS_TYPE_PT_GENERATE_LE
8365 | OPTS_TYPE_PT_ADD80
8366 | OPTS_TYPE_PT_ADDBITS14;
8367 kern_type = KERN_TYPE_MD55_SLTPW;
8368 dgst_size = DGST_SIZE_4_4;
8369 parse_func = ipb2_parse_hash;
8370 sort_by_digest = sort_by_digest_4_4;
8371 opti_type = OPTI_TYPE_ZERO_BYTE
8372 | OPTI_TYPE_PRECOMPUTE_INIT
8373 | OPTI_TYPE_EARLY_SKIP;
8374 dgst_pos0 = 0;
8375 dgst_pos1 = 3;
8376 dgst_pos2 = 2;
8377 dgst_pos3 = 1;
8378 break;
8379
8380 case 3000: hash_type = HASH_TYPE_LM;
8381 salt_type = SALT_TYPE_NONE;
8382 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8383 opts_type = OPTS_TYPE_PT_GENERATE_LE
8384 | OPTS_TYPE_PT_UPPER
8385 | OPTS_TYPE_PT_BITSLICE;
8386 kern_type = KERN_TYPE_LM;
8387 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8388 parse_func = lm_parse_hash;
8389 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8390 opti_type = OPTI_TYPE_ZERO_BYTE
8391 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8392 dgst_pos0 = 0;
8393 dgst_pos1 = 1;
8394 dgst_pos2 = 2;
8395 dgst_pos3 = 3;
8396 break;
8397
8398 case 3100: hash_type = HASH_TYPE_ORACLEH;
8399 salt_type = SALT_TYPE_INTERN;
8400 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8401 opts_type = OPTS_TYPE_PT_GENERATE_LE
8402 | OPTS_TYPE_PT_UPPER
8403 | OPTS_TYPE_ST_UPPER;
8404 kern_type = KERN_TYPE_ORACLEH;
8405 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8406 parse_func = oracleh_parse_hash;
8407 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8408 opti_type = OPTI_TYPE_ZERO_BYTE;
8409 dgst_pos0 = 0;
8410 dgst_pos1 = 1;
8411 dgst_pos2 = 2;
8412 dgst_pos3 = 3;
8413 break;
8414
8415 case 3200: hash_type = HASH_TYPE_BCRYPT;
8416 salt_type = SALT_TYPE_EMBEDDED;
8417 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8418 opts_type = OPTS_TYPE_PT_GENERATE_LE
8419 | OPTS_TYPE_ST_GENERATE_LE;
8420 kern_type = KERN_TYPE_BCRYPT;
8421 dgst_size = DGST_SIZE_4_6;
8422 parse_func = bcrypt_parse_hash;
8423 sort_by_digest = sort_by_digest_4_6;
8424 opti_type = OPTI_TYPE_ZERO_BYTE;
8425 dgst_pos0 = 0;
8426 dgst_pos1 = 1;
8427 dgst_pos2 = 2;
8428 dgst_pos3 = 3;
8429 break;
8430
8431 case 3710: hash_type = HASH_TYPE_MD5;
8432 salt_type = SALT_TYPE_INTERN;
8433 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8434 opts_type = OPTS_TYPE_PT_GENERATE_LE
8435 | OPTS_TYPE_PT_ADD80
8436 | OPTS_TYPE_PT_ADDBITS14;
8437 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8438 dgst_size = DGST_SIZE_4_4;
8439 parse_func = md5s_parse_hash;
8440 sort_by_digest = sort_by_digest_4_4;
8441 opti_type = OPTI_TYPE_ZERO_BYTE
8442 | OPTI_TYPE_PRECOMPUTE_INIT
8443 | OPTI_TYPE_PRECOMPUTE_MERKLE
8444 | OPTI_TYPE_EARLY_SKIP;
8445 dgst_pos0 = 0;
8446 dgst_pos1 = 3;
8447 dgst_pos2 = 2;
8448 dgst_pos3 = 1;
8449 break;
8450
8451 case 3711: hash_type = HASH_TYPE_MD5;
8452 salt_type = SALT_TYPE_EMBEDDED;
8453 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8454 opts_type = OPTS_TYPE_PT_GENERATE_LE
8455 | OPTS_TYPE_PT_ADD80
8456 | OPTS_TYPE_PT_ADDBITS14;
8457 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8458 dgst_size = DGST_SIZE_4_4;
8459 parse_func = mediawiki_b_parse_hash;
8460 sort_by_digest = sort_by_digest_4_4;
8461 opti_type = OPTI_TYPE_ZERO_BYTE
8462 | OPTI_TYPE_PRECOMPUTE_INIT
8463 | OPTI_TYPE_PRECOMPUTE_MERKLE
8464 | OPTI_TYPE_EARLY_SKIP;
8465 dgst_pos0 = 0;
8466 dgst_pos1 = 3;
8467 dgst_pos2 = 2;
8468 dgst_pos3 = 1;
8469 break;
8470
8471 case 3800: hash_type = HASH_TYPE_MD5;
8472 salt_type = SALT_TYPE_INTERN;
8473 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8474 opts_type = OPTS_TYPE_PT_GENERATE_LE
8475 | OPTS_TYPE_ST_ADDBITS14;
8476 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8477 dgst_size = DGST_SIZE_4_4;
8478 parse_func = md5s_parse_hash;
8479 sort_by_digest = sort_by_digest_4_4;
8480 opti_type = OPTI_TYPE_ZERO_BYTE
8481 | OPTI_TYPE_PRECOMPUTE_INIT
8482 | OPTI_TYPE_PRECOMPUTE_MERKLE
8483 | OPTI_TYPE_EARLY_SKIP
8484 | OPTI_TYPE_NOT_ITERATED
8485 | OPTI_TYPE_RAW_HASH;
8486 dgst_pos0 = 0;
8487 dgst_pos1 = 3;
8488 dgst_pos2 = 2;
8489 dgst_pos3 = 1;
8490 break;
8491
8492 case 4300: hash_type = HASH_TYPE_MD5;
8493 salt_type = SALT_TYPE_VIRTUAL;
8494 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8495 opts_type = OPTS_TYPE_PT_GENERATE_LE
8496 | OPTS_TYPE_PT_ADD80
8497 | OPTS_TYPE_PT_ADDBITS14
8498 | OPTS_TYPE_ST_ADD80;
8499 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8500 dgst_size = DGST_SIZE_4_4;
8501 parse_func = md5md5_parse_hash;
8502 sort_by_digest = sort_by_digest_4_4;
8503 opti_type = OPTI_TYPE_ZERO_BYTE
8504 | OPTI_TYPE_PRECOMPUTE_INIT
8505 | OPTI_TYPE_PRECOMPUTE_MERKLE
8506 | OPTI_TYPE_EARLY_SKIP;
8507 dgst_pos0 = 0;
8508 dgst_pos1 = 3;
8509 dgst_pos2 = 2;
8510 dgst_pos3 = 1;
8511 break;
8512
8513
8514 case 4400: hash_type = HASH_TYPE_MD5;
8515 salt_type = SALT_TYPE_NONE;
8516 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8517 opts_type = OPTS_TYPE_PT_GENERATE_BE
8518 | OPTS_TYPE_PT_ADD80
8519 | OPTS_TYPE_PT_ADDBITS15;
8520 kern_type = KERN_TYPE_MD5_SHA1;
8521 dgst_size = DGST_SIZE_4_4;
8522 parse_func = md5_parse_hash;
8523 sort_by_digest = sort_by_digest_4_4;
8524 opti_type = OPTI_TYPE_ZERO_BYTE
8525 | OPTI_TYPE_PRECOMPUTE_INIT
8526 | OPTI_TYPE_PRECOMPUTE_MERKLE
8527 | OPTI_TYPE_EARLY_SKIP
8528 | OPTI_TYPE_NOT_ITERATED
8529 | OPTI_TYPE_NOT_SALTED
8530 | OPTI_TYPE_RAW_HASH;
8531 dgst_pos0 = 0;
8532 dgst_pos1 = 3;
8533 dgst_pos2 = 2;
8534 dgst_pos3 = 1;
8535 break;
8536
8537 case 4500: hash_type = HASH_TYPE_SHA1;
8538 salt_type = SALT_TYPE_NONE;
8539 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8540 opts_type = OPTS_TYPE_PT_GENERATE_BE
8541 | OPTS_TYPE_PT_ADD80
8542 | OPTS_TYPE_PT_ADDBITS15;
8543 kern_type = KERN_TYPE_SHA11;
8544 dgst_size = DGST_SIZE_4_5;
8545 parse_func = sha1_parse_hash;
8546 sort_by_digest = sort_by_digest_4_5;
8547 opti_type = OPTI_TYPE_ZERO_BYTE
8548 | OPTI_TYPE_PRECOMPUTE_INIT
8549 | OPTI_TYPE_PRECOMPUTE_MERKLE
8550 | OPTI_TYPE_EARLY_SKIP
8551 | OPTI_TYPE_NOT_SALTED;
8552 dgst_pos0 = 3;
8553 dgst_pos1 = 4;
8554 dgst_pos2 = 2;
8555 dgst_pos3 = 1;
8556 break;
8557
8558 case 4700: hash_type = HASH_TYPE_SHA1;
8559 salt_type = SALT_TYPE_NONE;
8560 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8561 opts_type = OPTS_TYPE_PT_GENERATE_LE
8562 | OPTS_TYPE_PT_ADD80
8563 | OPTS_TYPE_PT_ADDBITS14;
8564 kern_type = KERN_TYPE_SHA1_MD5;
8565 dgst_size = DGST_SIZE_4_5;
8566 parse_func = sha1_parse_hash;
8567 sort_by_digest = sort_by_digest_4_5;
8568 opti_type = OPTI_TYPE_ZERO_BYTE
8569 | OPTI_TYPE_PRECOMPUTE_INIT
8570 | OPTI_TYPE_PRECOMPUTE_MERKLE
8571 | OPTI_TYPE_EARLY_SKIP
8572 | OPTI_TYPE_NOT_ITERATED
8573 | OPTI_TYPE_NOT_SALTED
8574 | OPTI_TYPE_RAW_HASH;
8575 dgst_pos0 = 3;
8576 dgst_pos1 = 4;
8577 dgst_pos2 = 2;
8578 dgst_pos3 = 1;
8579 break;
8580
8581 case 4800: hash_type = HASH_TYPE_MD5;
8582 salt_type = SALT_TYPE_EMBEDDED;
8583 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8584 opts_type = OPTS_TYPE_PT_GENERATE_LE
8585 | OPTS_TYPE_PT_ADDBITS14;
8586 kern_type = KERN_TYPE_MD5_CHAP;
8587 dgst_size = DGST_SIZE_4_4;
8588 parse_func = chap_parse_hash;
8589 sort_by_digest = sort_by_digest_4_4;
8590 opti_type = OPTI_TYPE_ZERO_BYTE
8591 | OPTI_TYPE_PRECOMPUTE_INIT
8592 | OPTI_TYPE_PRECOMPUTE_MERKLE
8593 | OPTI_TYPE_MEET_IN_MIDDLE
8594 | OPTI_TYPE_EARLY_SKIP
8595 | OPTI_TYPE_NOT_ITERATED
8596 | OPTI_TYPE_RAW_HASH;
8597 dgst_pos0 = 0;
8598 dgst_pos1 = 3;
8599 dgst_pos2 = 2;
8600 dgst_pos3 = 1;
8601 break;
8602
8603 case 4900: hash_type = HASH_TYPE_SHA1;
8604 salt_type = SALT_TYPE_INTERN;
8605 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8606 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8607 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8608 dgst_size = DGST_SIZE_4_5;
8609 parse_func = sha1s_parse_hash;
8610 sort_by_digest = sort_by_digest_4_5;
8611 opti_type = OPTI_TYPE_ZERO_BYTE
8612 | OPTI_TYPE_PRECOMPUTE_INIT
8613 | OPTI_TYPE_PRECOMPUTE_MERKLE
8614 | OPTI_TYPE_EARLY_SKIP;
8615 dgst_pos0 = 3;
8616 dgst_pos1 = 4;
8617 dgst_pos2 = 2;
8618 dgst_pos3 = 1;
8619 break;
8620
8621 case 5000: hash_type = HASH_TYPE_KECCAK;
8622 salt_type = SALT_TYPE_EMBEDDED;
8623 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8624 opts_type = OPTS_TYPE_PT_GENERATE_LE
8625 | OPTS_TYPE_PT_ADD01;
8626 kern_type = KERN_TYPE_KECCAK;
8627 dgst_size = DGST_SIZE_8_25;
8628 parse_func = keccak_parse_hash;
8629 sort_by_digest = sort_by_digest_8_25;
8630 opti_type = OPTI_TYPE_ZERO_BYTE
8631 | OPTI_TYPE_USES_BITS_64
8632 | OPTI_TYPE_RAW_HASH;
8633 dgst_pos0 = 2;
8634 dgst_pos1 = 3;
8635 dgst_pos2 = 4;
8636 dgst_pos3 = 5;
8637 break;
8638
8639 case 5100: hash_type = HASH_TYPE_MD5H;
8640 salt_type = SALT_TYPE_NONE;
8641 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8642 opts_type = OPTS_TYPE_PT_GENERATE_LE
8643 | OPTS_TYPE_PT_ADD80
8644 | OPTS_TYPE_PT_ADDBITS14;
8645 kern_type = KERN_TYPE_MD5H;
8646 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8647 parse_func = md5half_parse_hash;
8648 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8649 opti_type = OPTI_TYPE_ZERO_BYTE
8650 | OPTI_TYPE_RAW_HASH;
8651 dgst_pos0 = 0;
8652 dgst_pos1 = 1;
8653 dgst_pos2 = 2;
8654 dgst_pos3 = 3;
8655 break;
8656
8657 case 5200: hash_type = HASH_TYPE_SHA256;
8658 salt_type = SALT_TYPE_EMBEDDED;
8659 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8660 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8661 kern_type = KERN_TYPE_PSAFE3;
8662 dgst_size = DGST_SIZE_4_8;
8663 parse_func = psafe3_parse_hash;
8664 sort_by_digest = sort_by_digest_4_8;
8665 opti_type = OPTI_TYPE_ZERO_BYTE;
8666 dgst_pos0 = 0;
8667 dgst_pos1 = 1;
8668 dgst_pos2 = 2;
8669 dgst_pos3 = 3;
8670 break;
8671
8672 case 5300: hash_type = HASH_TYPE_MD5;
8673 salt_type = SALT_TYPE_EMBEDDED;
8674 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8675 opts_type = OPTS_TYPE_PT_GENERATE_LE
8676 | OPTS_TYPE_ST_ADD80;
8677 kern_type = KERN_TYPE_IKEPSK_MD5;
8678 dgst_size = DGST_SIZE_4_4;
8679 parse_func = ikepsk_md5_parse_hash;
8680 sort_by_digest = sort_by_digest_4_4;
8681 opti_type = OPTI_TYPE_ZERO_BYTE;
8682 dgst_pos0 = 0;
8683 dgst_pos1 = 3;
8684 dgst_pos2 = 2;
8685 dgst_pos3 = 1;
8686 break;
8687
8688 case 5400: hash_type = HASH_TYPE_SHA1;
8689 salt_type = SALT_TYPE_EMBEDDED;
8690 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8691 opts_type = OPTS_TYPE_PT_GENERATE_BE
8692 | OPTS_TYPE_ST_ADD80;
8693 kern_type = KERN_TYPE_IKEPSK_SHA1;
8694 dgst_size = DGST_SIZE_4_5;
8695 parse_func = ikepsk_sha1_parse_hash;
8696 sort_by_digest = sort_by_digest_4_5;
8697 opti_type = OPTI_TYPE_ZERO_BYTE;
8698 dgst_pos0 = 3;
8699 dgst_pos1 = 4;
8700 dgst_pos2 = 2;
8701 dgst_pos3 = 1;
8702 break;
8703
8704 case 5500: hash_type = HASH_TYPE_NETNTLM;
8705 salt_type = SALT_TYPE_EMBEDDED;
8706 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8707 opts_type = OPTS_TYPE_PT_GENERATE_LE
8708 | OPTS_TYPE_PT_ADD80
8709 | OPTS_TYPE_PT_ADDBITS14
8710 | OPTS_TYPE_PT_UNICODE
8711 | OPTS_TYPE_ST_HEX;
8712 kern_type = KERN_TYPE_NETNTLMv1;
8713 dgst_size = DGST_SIZE_4_4;
8714 parse_func = netntlmv1_parse_hash;
8715 sort_by_digest = sort_by_digest_4_4;
8716 opti_type = OPTI_TYPE_ZERO_BYTE
8717 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8718 dgst_pos0 = 0;
8719 dgst_pos1 = 1;
8720 dgst_pos2 = 2;
8721 dgst_pos3 = 3;
8722 break;
8723
8724 case 5600: hash_type = HASH_TYPE_MD5;
8725 salt_type = SALT_TYPE_EMBEDDED;
8726 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8727 opts_type = OPTS_TYPE_PT_GENERATE_LE
8728 | OPTS_TYPE_PT_ADD80
8729 | OPTS_TYPE_PT_ADDBITS14
8730 | OPTS_TYPE_PT_UNICODE;
8731 kern_type = KERN_TYPE_NETNTLMv2;
8732 dgst_size = DGST_SIZE_4_4;
8733 parse_func = netntlmv2_parse_hash;
8734 sort_by_digest = sort_by_digest_4_4;
8735 opti_type = OPTI_TYPE_ZERO_BYTE;
8736 dgst_pos0 = 0;
8737 dgst_pos1 = 3;
8738 dgst_pos2 = 2;
8739 dgst_pos3 = 1;
8740 break;
8741
8742 case 5700: hash_type = HASH_TYPE_SHA256;
8743 salt_type = SALT_TYPE_NONE;
8744 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8745 opts_type = OPTS_TYPE_PT_GENERATE_BE
8746 | OPTS_TYPE_PT_ADD80
8747 | OPTS_TYPE_PT_ADDBITS15;
8748 kern_type = KERN_TYPE_SHA256;
8749 dgst_size = DGST_SIZE_4_8;
8750 parse_func = cisco4_parse_hash;
8751 sort_by_digest = sort_by_digest_4_8;
8752 opti_type = OPTI_TYPE_ZERO_BYTE
8753 | OPTI_TYPE_PRECOMPUTE_INIT
8754 | OPTI_TYPE_PRECOMPUTE_MERKLE
8755 | OPTI_TYPE_EARLY_SKIP
8756 | OPTI_TYPE_NOT_ITERATED
8757 | OPTI_TYPE_NOT_SALTED
8758 | OPTI_TYPE_RAW_HASH;
8759 dgst_pos0 = 3;
8760 dgst_pos1 = 7;
8761 dgst_pos2 = 2;
8762 dgst_pos3 = 6;
8763 break;
8764
8765 case 5800: hash_type = HASH_TYPE_SHA1;
8766 salt_type = SALT_TYPE_INTERN;
8767 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8768 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8769 | OPTS_TYPE_ST_ADD80;
8770 kern_type = KERN_TYPE_ANDROIDPIN;
8771 dgst_size = DGST_SIZE_4_5;
8772 parse_func = androidpin_parse_hash;
8773 sort_by_digest = sort_by_digest_4_5;
8774 opti_type = OPTI_TYPE_ZERO_BYTE;
8775 dgst_pos0 = 0;
8776 dgst_pos1 = 1;
8777 dgst_pos2 = 2;
8778 dgst_pos3 = 3;
8779 break;
8780
8781 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8782 salt_type = SALT_TYPE_NONE;
8783 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8784 opts_type = OPTS_TYPE_PT_GENERATE_LE
8785 | OPTS_TYPE_PT_ADD80;
8786 kern_type = KERN_TYPE_RIPEMD160;
8787 dgst_size = DGST_SIZE_4_5;
8788 parse_func = ripemd160_parse_hash;
8789 sort_by_digest = sort_by_digest_4_5;
8790 opti_type = OPTI_TYPE_ZERO_BYTE;
8791 dgst_pos0 = 0;
8792 dgst_pos1 = 1;
8793 dgst_pos2 = 2;
8794 dgst_pos3 = 3;
8795 break;
8796
8797 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8798 salt_type = SALT_TYPE_NONE;
8799 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8800 opts_type = OPTS_TYPE_PT_GENERATE_BE
8801 | OPTS_TYPE_PT_ADD80;
8802 kern_type = KERN_TYPE_WHIRLPOOL;
8803 dgst_size = DGST_SIZE_4_16;
8804 parse_func = whirlpool_parse_hash;
8805 sort_by_digest = sort_by_digest_4_16;
8806 opti_type = OPTI_TYPE_ZERO_BYTE;
8807 dgst_pos0 = 0;
8808 dgst_pos1 = 1;
8809 dgst_pos2 = 2;
8810 dgst_pos3 = 3;
8811 break;
8812
8813 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8814 salt_type = SALT_TYPE_EMBEDDED;
8815 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8816 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8817 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8818 dgst_size = DGST_SIZE_4_5;
8819 parse_func = truecrypt_parse_hash_2k;
8820 sort_by_digest = sort_by_digest_4_5;
8821 opti_type = OPTI_TYPE_ZERO_BYTE;
8822 dgst_pos0 = 0;
8823 dgst_pos1 = 1;
8824 dgst_pos2 = 2;
8825 dgst_pos3 = 3;
8826 break;
8827
8828 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8829 salt_type = SALT_TYPE_EMBEDDED;
8830 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8831 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8832 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8833 dgst_size = DGST_SIZE_4_5;
8834 parse_func = truecrypt_parse_hash_2k;
8835 sort_by_digest = sort_by_digest_4_5;
8836 opti_type = OPTI_TYPE_ZERO_BYTE;
8837 dgst_pos0 = 0;
8838 dgst_pos1 = 1;
8839 dgst_pos2 = 2;
8840 dgst_pos3 = 3;
8841 break;
8842
8843 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8844 salt_type = SALT_TYPE_EMBEDDED;
8845 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8846 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8847 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8848 dgst_size = DGST_SIZE_4_5;
8849 parse_func = truecrypt_parse_hash_2k;
8850 sort_by_digest = sort_by_digest_4_5;
8851 opti_type = OPTI_TYPE_ZERO_BYTE;
8852 dgst_pos0 = 0;
8853 dgst_pos1 = 1;
8854 dgst_pos2 = 2;
8855 dgst_pos3 = 3;
8856 break;
8857
8858 case 6221: hash_type = HASH_TYPE_SHA512;
8859 salt_type = SALT_TYPE_EMBEDDED;
8860 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8861 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8862 kern_type = KERN_TYPE_TCSHA512_XTS512;
8863 dgst_size = DGST_SIZE_8_8;
8864 parse_func = truecrypt_parse_hash_1k;
8865 sort_by_digest = sort_by_digest_8_8;
8866 opti_type = OPTI_TYPE_ZERO_BYTE
8867 | OPTI_TYPE_USES_BITS_64;
8868 dgst_pos0 = 0;
8869 dgst_pos1 = 1;
8870 dgst_pos2 = 2;
8871 dgst_pos3 = 3;
8872 break;
8873
8874 case 6222: hash_type = HASH_TYPE_SHA512;
8875 salt_type = SALT_TYPE_EMBEDDED;
8876 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8877 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8878 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8879 dgst_size = DGST_SIZE_8_8;
8880 parse_func = truecrypt_parse_hash_1k;
8881 sort_by_digest = sort_by_digest_8_8;
8882 opti_type = OPTI_TYPE_ZERO_BYTE
8883 | OPTI_TYPE_USES_BITS_64;
8884 dgst_pos0 = 0;
8885 dgst_pos1 = 1;
8886 dgst_pos2 = 2;
8887 dgst_pos3 = 3;
8888 break;
8889
8890 case 6223: hash_type = HASH_TYPE_SHA512;
8891 salt_type = SALT_TYPE_EMBEDDED;
8892 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8893 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8894 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8895 dgst_size = DGST_SIZE_8_8;
8896 parse_func = truecrypt_parse_hash_1k;
8897 sort_by_digest = sort_by_digest_8_8;
8898 opti_type = OPTI_TYPE_ZERO_BYTE
8899 | OPTI_TYPE_USES_BITS_64;
8900 dgst_pos0 = 0;
8901 dgst_pos1 = 1;
8902 dgst_pos2 = 2;
8903 dgst_pos3 = 3;
8904 break;
8905
8906 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8907 salt_type = SALT_TYPE_EMBEDDED;
8908 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8909 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8910 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8911 dgst_size = DGST_SIZE_4_8;
8912 parse_func = truecrypt_parse_hash_1k;
8913 sort_by_digest = sort_by_digest_4_8;
8914 opti_type = OPTI_TYPE_ZERO_BYTE;
8915 dgst_pos0 = 0;
8916 dgst_pos1 = 1;
8917 dgst_pos2 = 2;
8918 dgst_pos3 = 3;
8919 break;
8920
8921 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8922 salt_type = SALT_TYPE_EMBEDDED;
8923 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8924 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8925 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8926 dgst_size = DGST_SIZE_4_8;
8927 parse_func = truecrypt_parse_hash_1k;
8928 sort_by_digest = sort_by_digest_4_8;
8929 opti_type = OPTI_TYPE_ZERO_BYTE;
8930 dgst_pos0 = 0;
8931 dgst_pos1 = 1;
8932 dgst_pos2 = 2;
8933 dgst_pos3 = 3;
8934 break;
8935
8936 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8937 salt_type = SALT_TYPE_EMBEDDED;
8938 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8939 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8940 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8941 dgst_size = DGST_SIZE_4_8;
8942 parse_func = truecrypt_parse_hash_1k;
8943 sort_by_digest = sort_by_digest_4_8;
8944 opti_type = OPTI_TYPE_ZERO_BYTE;
8945 dgst_pos0 = 0;
8946 dgst_pos1 = 1;
8947 dgst_pos2 = 2;
8948 dgst_pos3 = 3;
8949 break;
8950
8951 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8952 salt_type = SALT_TYPE_EMBEDDED;
8953 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8954 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8955 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8956 dgst_size = DGST_SIZE_4_5;
8957 parse_func = truecrypt_parse_hash_1k;
8958 sort_by_digest = sort_by_digest_4_5;
8959 opti_type = OPTI_TYPE_ZERO_BYTE;
8960 dgst_pos0 = 0;
8961 dgst_pos1 = 1;
8962 dgst_pos2 = 2;
8963 dgst_pos3 = 3;
8964 break;
8965
8966 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8967 salt_type = SALT_TYPE_EMBEDDED;
8968 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8969 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8970 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8971 dgst_size = DGST_SIZE_4_5;
8972 parse_func = truecrypt_parse_hash_1k;
8973 sort_by_digest = sort_by_digest_4_5;
8974 opti_type = OPTI_TYPE_ZERO_BYTE;
8975 dgst_pos0 = 0;
8976 dgst_pos1 = 1;
8977 dgst_pos2 = 2;
8978 dgst_pos3 = 3;
8979 break;
8980
8981 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8982 salt_type = SALT_TYPE_EMBEDDED;
8983 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8984 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8985 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8986 dgst_size = DGST_SIZE_4_5;
8987 parse_func = truecrypt_parse_hash_1k;
8988 sort_by_digest = sort_by_digest_4_5;
8989 opti_type = OPTI_TYPE_ZERO_BYTE;
8990 dgst_pos0 = 0;
8991 dgst_pos1 = 1;
8992 dgst_pos2 = 2;
8993 dgst_pos3 = 3;
8994 break;
8995
8996 case 6300: hash_type = HASH_TYPE_MD5;
8997 salt_type = SALT_TYPE_EMBEDDED;
8998 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8999 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9000 kern_type = KERN_TYPE_MD5AIX;
9001 dgst_size = DGST_SIZE_4_4;
9002 parse_func = md5aix_parse_hash;
9003 sort_by_digest = sort_by_digest_4_4;
9004 opti_type = OPTI_TYPE_ZERO_BYTE;
9005 dgst_pos0 = 0;
9006 dgst_pos1 = 1;
9007 dgst_pos2 = 2;
9008 dgst_pos3 = 3;
9009 break;
9010
9011 case 6400: hash_type = HASH_TYPE_SHA256;
9012 salt_type = SALT_TYPE_EMBEDDED;
9013 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9014 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9015 kern_type = KERN_TYPE_SHA256AIX;
9016 dgst_size = DGST_SIZE_4_8;
9017 parse_func = sha256aix_parse_hash;
9018 sort_by_digest = sort_by_digest_4_8;
9019 opti_type = OPTI_TYPE_ZERO_BYTE;
9020 dgst_pos0 = 0;
9021 dgst_pos1 = 1;
9022 dgst_pos2 = 2;
9023 dgst_pos3 = 3;
9024 break;
9025
9026 case 6500: hash_type = HASH_TYPE_SHA512;
9027 salt_type = SALT_TYPE_EMBEDDED;
9028 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9029 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9030 kern_type = KERN_TYPE_SHA512AIX;
9031 dgst_size = DGST_SIZE_8_8;
9032 parse_func = sha512aix_parse_hash;
9033 sort_by_digest = sort_by_digest_8_8;
9034 opti_type = OPTI_TYPE_ZERO_BYTE
9035 | OPTI_TYPE_USES_BITS_64;
9036 dgst_pos0 = 0;
9037 dgst_pos1 = 1;
9038 dgst_pos2 = 2;
9039 dgst_pos3 = 3;
9040 break;
9041
9042 case 6600: hash_type = HASH_TYPE_AES;
9043 salt_type = SALT_TYPE_EMBEDDED;
9044 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9045 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9046 kern_type = KERN_TYPE_AGILEKEY;
9047 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9048 parse_func = agilekey_parse_hash;
9049 sort_by_digest = sort_by_digest_4_5;
9050 opti_type = OPTI_TYPE_ZERO_BYTE;
9051 dgst_pos0 = 0;
9052 dgst_pos1 = 1;
9053 dgst_pos2 = 2;
9054 dgst_pos3 = 3;
9055 break;
9056
9057 case 6700: hash_type = HASH_TYPE_SHA1;
9058 salt_type = SALT_TYPE_EMBEDDED;
9059 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9060 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9061 kern_type = KERN_TYPE_SHA1AIX;
9062 dgst_size = DGST_SIZE_4_5;
9063 parse_func = sha1aix_parse_hash;
9064 sort_by_digest = sort_by_digest_4_5;
9065 opti_type = OPTI_TYPE_ZERO_BYTE;
9066 dgst_pos0 = 0;
9067 dgst_pos1 = 1;
9068 dgst_pos2 = 2;
9069 dgst_pos3 = 3;
9070 break;
9071
9072 case 6800: hash_type = HASH_TYPE_AES;
9073 salt_type = SALT_TYPE_EMBEDDED;
9074 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9075 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9076 kern_type = KERN_TYPE_LASTPASS;
9077 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9078 parse_func = lastpass_parse_hash;
9079 sort_by_digest = sort_by_digest_4_8;
9080 opti_type = OPTI_TYPE_ZERO_BYTE;
9081 dgst_pos0 = 0;
9082 dgst_pos1 = 1;
9083 dgst_pos2 = 2;
9084 dgst_pos3 = 3;
9085 break;
9086
9087 case 6900: hash_type = HASH_TYPE_GOST;
9088 salt_type = SALT_TYPE_NONE;
9089 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9090 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9091 kern_type = KERN_TYPE_GOST;
9092 dgst_size = DGST_SIZE_4_8;
9093 parse_func = gost_parse_hash;
9094 sort_by_digest = sort_by_digest_4_8;
9095 opti_type = OPTI_TYPE_ZERO_BYTE;
9096 dgst_pos0 = 0;
9097 dgst_pos1 = 1;
9098 dgst_pos2 = 2;
9099 dgst_pos3 = 3;
9100 break;
9101
9102 case 7100: hash_type = HASH_TYPE_SHA512;
9103 salt_type = SALT_TYPE_EMBEDDED;
9104 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9105 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9106 kern_type = KERN_TYPE_PBKDF2_SHA512;
9107 dgst_size = DGST_SIZE_8_16;
9108 parse_func = sha512osx_parse_hash;
9109 sort_by_digest = sort_by_digest_8_16;
9110 opti_type = OPTI_TYPE_ZERO_BYTE
9111 | OPTI_TYPE_USES_BITS_64;
9112 dgst_pos0 = 0;
9113 dgst_pos1 = 1;
9114 dgst_pos2 = 2;
9115 dgst_pos3 = 3;
9116 break;
9117
9118 case 7200: hash_type = HASH_TYPE_SHA512;
9119 salt_type = SALT_TYPE_EMBEDDED;
9120 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9121 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9122 kern_type = KERN_TYPE_PBKDF2_SHA512;
9123 dgst_size = DGST_SIZE_8_16;
9124 parse_func = sha512grub_parse_hash;
9125 sort_by_digest = sort_by_digest_8_16;
9126 opti_type = OPTI_TYPE_ZERO_BYTE
9127 | OPTI_TYPE_USES_BITS_64;
9128 dgst_pos0 = 0;
9129 dgst_pos1 = 1;
9130 dgst_pos2 = 2;
9131 dgst_pos3 = 3;
9132 break;
9133
9134 case 7300: hash_type = HASH_TYPE_SHA1;
9135 salt_type = SALT_TYPE_EMBEDDED;
9136 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9137 opts_type = OPTS_TYPE_PT_GENERATE_BE
9138 | OPTS_TYPE_ST_ADD80
9139 | OPTS_TYPE_ST_ADDBITS15;
9140 kern_type = KERN_TYPE_RAKP;
9141 dgst_size = DGST_SIZE_4_5;
9142 parse_func = rakp_parse_hash;
9143 sort_by_digest = sort_by_digest_4_5;
9144 opti_type = OPTI_TYPE_ZERO_BYTE
9145 | OPTI_TYPE_NOT_ITERATED;
9146 dgst_pos0 = 3;
9147 dgst_pos1 = 4;
9148 dgst_pos2 = 2;
9149 dgst_pos3 = 1;
9150 break;
9151
9152 case 7400: hash_type = HASH_TYPE_SHA256;
9153 salt_type = SALT_TYPE_EMBEDDED;
9154 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9155 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9156 kern_type = KERN_TYPE_SHA256CRYPT;
9157 dgst_size = DGST_SIZE_4_8;
9158 parse_func = sha256crypt_parse_hash;
9159 sort_by_digest = sort_by_digest_4_8;
9160 opti_type = OPTI_TYPE_ZERO_BYTE;
9161 dgst_pos0 = 0;
9162 dgst_pos1 = 1;
9163 dgst_pos2 = 2;
9164 dgst_pos3 = 3;
9165 break;
9166
9167 case 7500: hash_type = HASH_TYPE_KRB5PA;
9168 salt_type = SALT_TYPE_EMBEDDED;
9169 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9170 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9171 kern_type = KERN_TYPE_KRB5PA;
9172 dgst_size = DGST_SIZE_4_4;
9173 parse_func = krb5pa_parse_hash;
9174 sort_by_digest = sort_by_digest_4_4;
9175 opti_type = OPTI_TYPE_ZERO_BYTE
9176 | OPTI_TYPE_NOT_ITERATED;
9177 dgst_pos0 = 0;
9178 dgst_pos1 = 1;
9179 dgst_pos2 = 2;
9180 dgst_pos3 = 3;
9181 break;
9182
9183 case 7600: hash_type = HASH_TYPE_SHA1;
9184 salt_type = SALT_TYPE_INTERN;
9185 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9186 opts_type = OPTS_TYPE_PT_GENERATE_BE
9187 | OPTS_TYPE_PT_ADD80
9188 | OPTS_TYPE_PT_ADDBITS15;
9189 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9190 dgst_size = DGST_SIZE_4_5;
9191 parse_func = redmine_parse_hash;
9192 sort_by_digest = sort_by_digest_4_5;
9193 opti_type = OPTI_TYPE_ZERO_BYTE
9194 | OPTI_TYPE_PRECOMPUTE_INIT
9195 | OPTI_TYPE_EARLY_SKIP
9196 | OPTI_TYPE_NOT_ITERATED
9197 | OPTI_TYPE_PREPENDED_SALT;
9198 dgst_pos0 = 3;
9199 dgst_pos1 = 4;
9200 dgst_pos2 = 2;
9201 dgst_pos3 = 1;
9202 break;
9203
9204 case 7700: hash_type = HASH_TYPE_SAPB;
9205 salt_type = SALT_TYPE_EMBEDDED;
9206 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9207 opts_type = OPTS_TYPE_PT_GENERATE_LE
9208 | OPTS_TYPE_PT_UPPER
9209 | OPTS_TYPE_ST_UPPER;
9210 kern_type = KERN_TYPE_SAPB;
9211 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9212 parse_func = sapb_parse_hash;
9213 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9214 opti_type = OPTI_TYPE_ZERO_BYTE
9215 | OPTI_TYPE_PRECOMPUTE_INIT
9216 | OPTI_TYPE_NOT_ITERATED;
9217 dgst_pos0 = 0;
9218 dgst_pos1 = 1;
9219 dgst_pos2 = 2;
9220 dgst_pos3 = 3;
9221 break;
9222
9223 case 7800: hash_type = HASH_TYPE_SAPG;
9224 salt_type = SALT_TYPE_EMBEDDED;
9225 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9226 opts_type = OPTS_TYPE_PT_GENERATE_BE
9227 | OPTS_TYPE_ST_ADD80
9228 | OPTS_TYPE_ST_UPPER;
9229 kern_type = KERN_TYPE_SAPG;
9230 dgst_size = DGST_SIZE_4_5;
9231 parse_func = sapg_parse_hash;
9232 sort_by_digest = sort_by_digest_4_5;
9233 opti_type = OPTI_TYPE_ZERO_BYTE
9234 | OPTI_TYPE_PRECOMPUTE_INIT
9235 | OPTI_TYPE_NOT_ITERATED;
9236 dgst_pos0 = 3;
9237 dgst_pos1 = 4;
9238 dgst_pos2 = 2;
9239 dgst_pos3 = 1;
9240 break;
9241
9242 case 7900: hash_type = HASH_TYPE_SHA512;
9243 salt_type = SALT_TYPE_EMBEDDED;
9244 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9245 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9246 kern_type = KERN_TYPE_DRUPAL7;
9247 dgst_size = DGST_SIZE_8_8;
9248 parse_func = drupal7_parse_hash;
9249 sort_by_digest = sort_by_digest_8_8;
9250 opti_type = OPTI_TYPE_ZERO_BYTE
9251 | OPTI_TYPE_USES_BITS_64;
9252 dgst_pos0 = 0;
9253 dgst_pos1 = 1;
9254 dgst_pos2 = 2;
9255 dgst_pos3 = 3;
9256 break;
9257
9258 case 8000: hash_type = HASH_TYPE_SHA256;
9259 salt_type = SALT_TYPE_EMBEDDED;
9260 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9261 opts_type = OPTS_TYPE_PT_GENERATE_BE
9262 | OPTS_TYPE_PT_UNICODE
9263 | OPTS_TYPE_ST_ADD80
9264 | OPTS_TYPE_ST_HEX;
9265 kern_type = KERN_TYPE_SYBASEASE;
9266 dgst_size = DGST_SIZE_4_8;
9267 parse_func = sybasease_parse_hash;
9268 sort_by_digest = sort_by_digest_4_8;
9269 opti_type = OPTI_TYPE_ZERO_BYTE
9270 | OPTI_TYPE_PRECOMPUTE_INIT
9271 | OPTI_TYPE_EARLY_SKIP
9272 | OPTI_TYPE_NOT_ITERATED
9273 | OPTI_TYPE_RAW_HASH;
9274 dgst_pos0 = 3;
9275 dgst_pos1 = 7;
9276 dgst_pos2 = 2;
9277 dgst_pos3 = 6;
9278 break;
9279
9280 case 8100: hash_type = HASH_TYPE_SHA1;
9281 salt_type = SALT_TYPE_EMBEDDED;
9282 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9283 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9284 kern_type = KERN_TYPE_NETSCALER;
9285 dgst_size = DGST_SIZE_4_5;
9286 parse_func = netscaler_parse_hash;
9287 sort_by_digest = sort_by_digest_4_5;
9288 opti_type = OPTI_TYPE_ZERO_BYTE
9289 | OPTI_TYPE_PRECOMPUTE_INIT
9290 | OPTI_TYPE_PRECOMPUTE_MERKLE
9291 | OPTI_TYPE_EARLY_SKIP
9292 | OPTI_TYPE_NOT_ITERATED
9293 | OPTI_TYPE_PREPENDED_SALT
9294 | OPTI_TYPE_RAW_HASH;
9295 dgst_pos0 = 3;
9296 dgst_pos1 = 4;
9297 dgst_pos2 = 2;
9298 dgst_pos3 = 1;
9299 break;
9300
9301 case 8200: hash_type = HASH_TYPE_SHA256;
9302 salt_type = SALT_TYPE_EMBEDDED;
9303 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9304 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9305 kern_type = KERN_TYPE_CLOUDKEY;
9306 dgst_size = DGST_SIZE_4_8;
9307 parse_func = cloudkey_parse_hash;
9308 sort_by_digest = sort_by_digest_4_8;
9309 opti_type = OPTI_TYPE_ZERO_BYTE;
9310 dgst_pos0 = 0;
9311 dgst_pos1 = 1;
9312 dgst_pos2 = 2;
9313 dgst_pos3 = 3;
9314 break;
9315
9316 case 8300: hash_type = HASH_TYPE_SHA1;
9317 salt_type = SALT_TYPE_EMBEDDED;
9318 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9319 opts_type = OPTS_TYPE_PT_GENERATE_BE
9320 | OPTS_TYPE_ST_HEX
9321 | OPTS_TYPE_ST_ADD80;
9322 kern_type = KERN_TYPE_NSEC3;
9323 dgst_size = DGST_SIZE_4_5;
9324 parse_func = nsec3_parse_hash;
9325 sort_by_digest = sort_by_digest_4_5;
9326 opti_type = OPTI_TYPE_ZERO_BYTE;
9327 dgst_pos0 = 3;
9328 dgst_pos1 = 4;
9329 dgst_pos2 = 2;
9330 dgst_pos3 = 1;
9331 break;
9332
9333 case 8400: hash_type = HASH_TYPE_SHA1;
9334 salt_type = SALT_TYPE_INTERN;
9335 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9336 opts_type = OPTS_TYPE_PT_GENERATE_BE
9337 | OPTS_TYPE_PT_ADD80
9338 | OPTS_TYPE_PT_ADDBITS15;
9339 kern_type = KERN_TYPE_WBB3;
9340 dgst_size = DGST_SIZE_4_5;
9341 parse_func = wbb3_parse_hash;
9342 sort_by_digest = sort_by_digest_4_5;
9343 opti_type = OPTI_TYPE_ZERO_BYTE
9344 | OPTI_TYPE_PRECOMPUTE_INIT
9345 | OPTI_TYPE_NOT_ITERATED;
9346 dgst_pos0 = 3;
9347 dgst_pos1 = 4;
9348 dgst_pos2 = 2;
9349 dgst_pos3 = 1;
9350 break;
9351
9352 case 8500: hash_type = HASH_TYPE_DESRACF;
9353 salt_type = SALT_TYPE_EMBEDDED;
9354 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9355 opts_type = OPTS_TYPE_PT_GENERATE_LE
9356 | OPTS_TYPE_ST_UPPER;
9357 kern_type = KERN_TYPE_RACF;
9358 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9359 parse_func = racf_parse_hash;
9360 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9361 opti_type = OPTI_TYPE_ZERO_BYTE
9362 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9363 dgst_pos0 = 0;
9364 dgst_pos1 = 1;
9365 dgst_pos2 = 2;
9366 dgst_pos3 = 3;
9367 break;
9368
9369 case 8600: hash_type = HASH_TYPE_LOTUS5;
9370 salt_type = SALT_TYPE_NONE;
9371 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9372 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9373 kern_type = KERN_TYPE_LOTUS5;
9374 dgst_size = DGST_SIZE_4_4;
9375 parse_func = lotus5_parse_hash;
9376 sort_by_digest = sort_by_digest_4_4;
9377 opti_type = OPTI_TYPE_EARLY_SKIP
9378 | OPTI_TYPE_NOT_ITERATED
9379 | OPTI_TYPE_NOT_SALTED
9380 | OPTI_TYPE_RAW_HASH;
9381 dgst_pos0 = 0;
9382 dgst_pos1 = 1;
9383 dgst_pos2 = 2;
9384 dgst_pos3 = 3;
9385 break;
9386
9387 case 8700: hash_type = HASH_TYPE_LOTUS6;
9388 salt_type = SALT_TYPE_EMBEDDED;
9389 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9390 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9391 kern_type = KERN_TYPE_LOTUS6;
9392 dgst_size = DGST_SIZE_4_4;
9393 parse_func = lotus6_parse_hash;
9394 sort_by_digest = sort_by_digest_4_4;
9395 opti_type = OPTI_TYPE_EARLY_SKIP
9396 | OPTI_TYPE_NOT_ITERATED
9397 | OPTI_TYPE_RAW_HASH;
9398 dgst_pos0 = 0;
9399 dgst_pos1 = 1;
9400 dgst_pos2 = 2;
9401 dgst_pos3 = 3;
9402 break;
9403
9404 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9405 salt_type = SALT_TYPE_EMBEDDED;
9406 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9407 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9408 kern_type = KERN_TYPE_ANDROIDFDE;
9409 dgst_size = DGST_SIZE_4_4;
9410 parse_func = androidfde_parse_hash;
9411 sort_by_digest = sort_by_digest_4_4;
9412 opti_type = OPTI_TYPE_ZERO_BYTE;
9413 dgst_pos0 = 0;
9414 dgst_pos1 = 1;
9415 dgst_pos2 = 2;
9416 dgst_pos3 = 3;
9417 break;
9418
9419 case 8900: hash_type = HASH_TYPE_SCRYPT;
9420 salt_type = SALT_TYPE_EMBEDDED;
9421 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9422 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9423 kern_type = KERN_TYPE_SCRYPT;
9424 dgst_size = DGST_SIZE_4_8;
9425 parse_func = scrypt_parse_hash;
9426 sort_by_digest = sort_by_digest_4_8;
9427 opti_type = OPTI_TYPE_ZERO_BYTE;
9428 dgst_pos0 = 0;
9429 dgst_pos1 = 1;
9430 dgst_pos2 = 2;
9431 dgst_pos3 = 3;
9432 break;
9433
9434 case 9000: hash_type = HASH_TYPE_SHA1;
9435 salt_type = SALT_TYPE_EMBEDDED;
9436 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9437 opts_type = OPTS_TYPE_PT_GENERATE_LE
9438 | OPTS_TYPE_ST_GENERATE_LE;
9439 kern_type = KERN_TYPE_PSAFE2;
9440 dgst_size = DGST_SIZE_4_5;
9441 parse_func = psafe2_parse_hash;
9442 sort_by_digest = sort_by_digest_4_5;
9443 opti_type = OPTI_TYPE_ZERO_BYTE;
9444 dgst_pos0 = 0;
9445 dgst_pos1 = 1;
9446 dgst_pos2 = 2;
9447 dgst_pos3 = 3;
9448 break;
9449
9450 case 9100: hash_type = HASH_TYPE_LOTUS8;
9451 salt_type = SALT_TYPE_EMBEDDED;
9452 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9453 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9454 kern_type = KERN_TYPE_LOTUS8;
9455 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9456 parse_func = lotus8_parse_hash;
9457 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9458 opti_type = OPTI_TYPE_ZERO_BYTE;
9459 dgst_pos0 = 0;
9460 dgst_pos1 = 1;
9461 dgst_pos2 = 2;
9462 dgst_pos3 = 3;
9463 break;
9464
9465 case 9200: hash_type = HASH_TYPE_SHA256;
9466 salt_type = SALT_TYPE_EMBEDDED;
9467 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9468 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9469 kern_type = KERN_TYPE_PBKDF2_SHA256;
9470 dgst_size = DGST_SIZE_4_32;
9471 parse_func = cisco8_parse_hash;
9472 sort_by_digest = sort_by_digest_4_32;
9473 opti_type = OPTI_TYPE_ZERO_BYTE;
9474 dgst_pos0 = 0;
9475 dgst_pos1 = 1;
9476 dgst_pos2 = 2;
9477 dgst_pos3 = 3;
9478 break;
9479
9480 case 9300: hash_type = HASH_TYPE_SCRYPT;
9481 salt_type = SALT_TYPE_EMBEDDED;
9482 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9483 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9484 kern_type = KERN_TYPE_SCRYPT;
9485 dgst_size = DGST_SIZE_4_8;
9486 parse_func = cisco9_parse_hash;
9487 sort_by_digest = sort_by_digest_4_8;
9488 opti_type = OPTI_TYPE_ZERO_BYTE;
9489 dgst_pos0 = 0;
9490 dgst_pos1 = 1;
9491 dgst_pos2 = 2;
9492 dgst_pos3 = 3;
9493 break;
9494
9495 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9496 salt_type = SALT_TYPE_EMBEDDED;
9497 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9498 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9499 kern_type = KERN_TYPE_OFFICE2007;
9500 dgst_size = DGST_SIZE_4_4;
9501 parse_func = office2007_parse_hash;
9502 sort_by_digest = sort_by_digest_4_4;
9503 opti_type = OPTI_TYPE_ZERO_BYTE;
9504 dgst_pos0 = 0;
9505 dgst_pos1 = 1;
9506 dgst_pos2 = 2;
9507 dgst_pos3 = 3;
9508 break;
9509
9510 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9511 salt_type = SALT_TYPE_EMBEDDED;
9512 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9513 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9514 kern_type = KERN_TYPE_OFFICE2010;
9515 dgst_size = DGST_SIZE_4_4;
9516 parse_func = office2010_parse_hash;
9517 sort_by_digest = sort_by_digest_4_4;
9518 opti_type = OPTI_TYPE_ZERO_BYTE;
9519 dgst_pos0 = 0;
9520 dgst_pos1 = 1;
9521 dgst_pos2 = 2;
9522 dgst_pos3 = 3;
9523 break;
9524
9525 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9526 salt_type = SALT_TYPE_EMBEDDED;
9527 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9528 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9529 kern_type = KERN_TYPE_OFFICE2013;
9530 dgst_size = DGST_SIZE_4_4;
9531 parse_func = office2013_parse_hash;
9532 sort_by_digest = sort_by_digest_4_4;
9533 opti_type = OPTI_TYPE_ZERO_BYTE;
9534 dgst_pos0 = 0;
9535 dgst_pos1 = 1;
9536 dgst_pos2 = 2;
9537 dgst_pos3 = 3;
9538 break;
9539
9540 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9541 salt_type = SALT_TYPE_EMBEDDED;
9542 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9543 opts_type = OPTS_TYPE_PT_GENERATE_LE
9544 | OPTS_TYPE_PT_ADD80
9545 | OPTS_TYPE_PT_UNICODE;
9546 kern_type = KERN_TYPE_OLDOFFICE01;
9547 dgst_size = DGST_SIZE_4_4;
9548 parse_func = oldoffice01_parse_hash;
9549 sort_by_digest = sort_by_digest_4_4;
9550 opti_type = OPTI_TYPE_ZERO_BYTE
9551 | OPTI_TYPE_PRECOMPUTE_INIT
9552 | OPTI_TYPE_NOT_ITERATED;
9553 dgst_pos0 = 0;
9554 dgst_pos1 = 1;
9555 dgst_pos2 = 2;
9556 dgst_pos3 = 3;
9557 break;
9558
9559 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9560 salt_type = SALT_TYPE_EMBEDDED;
9561 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9562 opts_type = OPTS_TYPE_PT_GENERATE_LE
9563 | OPTS_TYPE_PT_ADD80;
9564 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9565 dgst_size = DGST_SIZE_4_4;
9566 parse_func = oldoffice01cm1_parse_hash;
9567 sort_by_digest = sort_by_digest_4_4;
9568 opti_type = OPTI_TYPE_ZERO_BYTE
9569 | OPTI_TYPE_PRECOMPUTE_INIT
9570 | OPTI_TYPE_NOT_ITERATED;
9571 dgst_pos0 = 0;
9572 dgst_pos1 = 1;
9573 dgst_pos2 = 2;
9574 dgst_pos3 = 3;
9575 break;
9576
9577 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9578 salt_type = SALT_TYPE_EMBEDDED;
9579 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9580 opts_type = OPTS_TYPE_PT_GENERATE_LE
9581 | OPTS_TYPE_PT_ADD80
9582 | OPTS_TYPE_PT_UNICODE
9583 | OPTS_TYPE_PT_NEVERCRACK;
9584 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9585 dgst_size = DGST_SIZE_4_4;
9586 parse_func = oldoffice01cm2_parse_hash;
9587 sort_by_digest = sort_by_digest_4_4;
9588 opti_type = OPTI_TYPE_ZERO_BYTE
9589 | OPTI_TYPE_PRECOMPUTE_INIT
9590 | OPTI_TYPE_NOT_ITERATED;
9591 dgst_pos0 = 0;
9592 dgst_pos1 = 1;
9593 dgst_pos2 = 2;
9594 dgst_pos3 = 3;
9595 break;
9596
9597 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9598 salt_type = SALT_TYPE_EMBEDDED;
9599 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9600 opts_type = OPTS_TYPE_PT_GENERATE_BE
9601 | OPTS_TYPE_PT_ADD80
9602 | OPTS_TYPE_PT_UNICODE;
9603 kern_type = KERN_TYPE_OLDOFFICE34;
9604 dgst_size = DGST_SIZE_4_4;
9605 parse_func = oldoffice34_parse_hash;
9606 sort_by_digest = sort_by_digest_4_4;
9607 opti_type = OPTI_TYPE_ZERO_BYTE
9608 | OPTI_TYPE_PRECOMPUTE_INIT
9609 | OPTI_TYPE_NOT_ITERATED;
9610 dgst_pos0 = 0;
9611 dgst_pos1 = 1;
9612 dgst_pos2 = 2;
9613 dgst_pos3 = 3;
9614 break;
9615
9616 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9617 salt_type = SALT_TYPE_EMBEDDED;
9618 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9619 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9620 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9621 dgst_size = DGST_SIZE_4_4;
9622 parse_func = oldoffice34cm1_parse_hash;
9623 sort_by_digest = sort_by_digest_4_4;
9624 opti_type = OPTI_TYPE_ZERO_BYTE
9625 | OPTI_TYPE_PRECOMPUTE_INIT
9626 | OPTI_TYPE_NOT_ITERATED;
9627 dgst_pos0 = 0;
9628 dgst_pos1 = 1;
9629 dgst_pos2 = 2;
9630 dgst_pos3 = 3;
9631 break;
9632
9633 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9634 salt_type = SALT_TYPE_EMBEDDED;
9635 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9636 opts_type = OPTS_TYPE_PT_GENERATE_BE
9637 | OPTS_TYPE_PT_ADD80
9638 | OPTS_TYPE_PT_UNICODE
9639 | OPTS_TYPE_PT_NEVERCRACK;
9640 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9641 dgst_size = DGST_SIZE_4_4;
9642 parse_func = oldoffice34cm2_parse_hash;
9643 sort_by_digest = sort_by_digest_4_4;
9644 opti_type = OPTI_TYPE_ZERO_BYTE
9645 | OPTI_TYPE_PRECOMPUTE_INIT
9646 | OPTI_TYPE_NOT_ITERATED;
9647 dgst_pos0 = 0;
9648 dgst_pos1 = 1;
9649 dgst_pos2 = 2;
9650 dgst_pos3 = 3;
9651 break;
9652
9653 case 9900: hash_type = HASH_TYPE_MD5;
9654 salt_type = SALT_TYPE_NONE;
9655 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9656 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9657 kern_type = KERN_TYPE_RADMIN2;
9658 dgst_size = DGST_SIZE_4_4;
9659 parse_func = radmin2_parse_hash;
9660 sort_by_digest = sort_by_digest_4_4;
9661 opti_type = OPTI_TYPE_ZERO_BYTE
9662 | OPTI_TYPE_PRECOMPUTE_INIT
9663 | OPTI_TYPE_EARLY_SKIP
9664 | OPTI_TYPE_NOT_ITERATED
9665 | OPTI_TYPE_NOT_SALTED;
9666 dgst_pos0 = 0;
9667 dgst_pos1 = 3;
9668 dgst_pos2 = 2;
9669 dgst_pos3 = 1;
9670 break;
9671
9672 case 10000: hash_type = HASH_TYPE_SHA256;
9673 salt_type = SALT_TYPE_EMBEDDED;
9674 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9675 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9676 kern_type = KERN_TYPE_PBKDF2_SHA256;
9677 dgst_size = DGST_SIZE_4_32;
9678 parse_func = djangopbkdf2_parse_hash;
9679 sort_by_digest = sort_by_digest_4_32;
9680 opti_type = OPTI_TYPE_ZERO_BYTE;
9681 dgst_pos0 = 0;
9682 dgst_pos1 = 1;
9683 dgst_pos2 = 2;
9684 dgst_pos3 = 3;
9685 break;
9686
9687 case 10100: hash_type = HASH_TYPE_SIPHASH;
9688 salt_type = SALT_TYPE_EMBEDDED;
9689 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9690 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9691 kern_type = KERN_TYPE_SIPHASH;
9692 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9693 parse_func = siphash_parse_hash;
9694 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9695 opti_type = OPTI_TYPE_ZERO_BYTE
9696 | OPTI_TYPE_NOT_ITERATED
9697 | OPTI_TYPE_RAW_HASH;
9698 dgst_pos0 = 0;
9699 dgst_pos1 = 1;
9700 dgst_pos2 = 2;
9701 dgst_pos3 = 3;
9702 break;
9703
9704 case 10200: hash_type = HASH_TYPE_MD5;
9705 salt_type = SALT_TYPE_EMBEDDED;
9706 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9707 opts_type = OPTS_TYPE_PT_GENERATE_LE
9708 | OPTS_TYPE_ST_ADD80
9709 | OPTS_TYPE_ST_ADDBITS14;
9710 kern_type = KERN_TYPE_HMACMD5_PW;
9711 dgst_size = DGST_SIZE_4_4;
9712 parse_func = crammd5_parse_hash;
9713 sort_by_digest = sort_by_digest_4_4;
9714 opti_type = OPTI_TYPE_ZERO_BYTE
9715 | OPTI_TYPE_NOT_ITERATED;
9716 dgst_pos0 = 0;
9717 dgst_pos1 = 3;
9718 dgst_pos2 = 2;
9719 dgst_pos3 = 1;
9720 break;
9721
9722 case 10300: hash_type = HASH_TYPE_SHA1;
9723 salt_type = SALT_TYPE_EMBEDDED;
9724 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9725 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9726 kern_type = KERN_TYPE_SAPH_SHA1;
9727 dgst_size = DGST_SIZE_4_5;
9728 parse_func = saph_sha1_parse_hash;
9729 sort_by_digest = sort_by_digest_4_5;
9730 opti_type = OPTI_TYPE_ZERO_BYTE;
9731 dgst_pos0 = 0;
9732 dgst_pos1 = 1;
9733 dgst_pos2 = 2;
9734 dgst_pos3 = 3;
9735 break;
9736
9737 case 10400: hash_type = HASH_TYPE_PDFU16;
9738 salt_type = SALT_TYPE_EMBEDDED;
9739 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9740 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9741 kern_type = KERN_TYPE_PDF11;
9742 dgst_size = DGST_SIZE_4_4;
9743 parse_func = pdf11_parse_hash;
9744 sort_by_digest = sort_by_digest_4_4;
9745 opti_type = OPTI_TYPE_ZERO_BYTE
9746 | OPTI_TYPE_NOT_ITERATED;
9747 dgst_pos0 = 0;
9748 dgst_pos1 = 1;
9749 dgst_pos2 = 2;
9750 dgst_pos3 = 3;
9751 break;
9752
9753 case 10410: hash_type = HASH_TYPE_PDFU16;
9754 salt_type = SALT_TYPE_EMBEDDED;
9755 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9756 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9757 kern_type = KERN_TYPE_PDF11CM1;
9758 dgst_size = DGST_SIZE_4_4;
9759 parse_func = pdf11cm1_parse_hash;
9760 sort_by_digest = sort_by_digest_4_4;
9761 opti_type = OPTI_TYPE_ZERO_BYTE
9762 | OPTI_TYPE_NOT_ITERATED;
9763 dgst_pos0 = 0;
9764 dgst_pos1 = 1;
9765 dgst_pos2 = 2;
9766 dgst_pos3 = 3;
9767 break;
9768
9769 case 10420: hash_type = HASH_TYPE_PDFU16;
9770 salt_type = SALT_TYPE_EMBEDDED;
9771 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9772 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9773 kern_type = KERN_TYPE_PDF11CM2;
9774 dgst_size = DGST_SIZE_4_4;
9775 parse_func = pdf11cm2_parse_hash;
9776 sort_by_digest = sort_by_digest_4_4;
9777 opti_type = OPTI_TYPE_ZERO_BYTE
9778 | OPTI_TYPE_NOT_ITERATED;
9779 dgst_pos0 = 0;
9780 dgst_pos1 = 1;
9781 dgst_pos2 = 2;
9782 dgst_pos3 = 3;
9783 break;
9784
9785 case 10500: hash_type = HASH_TYPE_PDFU16;
9786 salt_type = SALT_TYPE_EMBEDDED;
9787 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9788 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9789 kern_type = KERN_TYPE_PDF14;
9790 dgst_size = DGST_SIZE_4_4;
9791 parse_func = pdf14_parse_hash;
9792 sort_by_digest = sort_by_digest_4_4;
9793 opti_type = OPTI_TYPE_ZERO_BYTE
9794 | OPTI_TYPE_NOT_ITERATED;
9795 dgst_pos0 = 0;
9796 dgst_pos1 = 1;
9797 dgst_pos2 = 2;
9798 dgst_pos3 = 3;
9799 break;
9800
9801 case 10600: hash_type = HASH_TYPE_SHA256;
9802 salt_type = SALT_TYPE_EMBEDDED;
9803 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9804 opts_type = OPTS_TYPE_PT_GENERATE_BE
9805 | OPTS_TYPE_ST_ADD80
9806 | OPTS_TYPE_ST_ADDBITS15
9807 | OPTS_TYPE_HASH_COPY;
9808 kern_type = KERN_TYPE_SHA256_PWSLT;
9809 dgst_size = DGST_SIZE_4_8;
9810 parse_func = pdf17l3_parse_hash;
9811 sort_by_digest = sort_by_digest_4_8;
9812 opti_type = OPTI_TYPE_ZERO_BYTE
9813 | OPTI_TYPE_PRECOMPUTE_INIT
9814 | OPTI_TYPE_PRECOMPUTE_MERKLE
9815 | OPTI_TYPE_EARLY_SKIP
9816 | OPTI_TYPE_NOT_ITERATED
9817 | OPTI_TYPE_APPENDED_SALT
9818 | OPTI_TYPE_RAW_HASH;
9819 dgst_pos0 = 3;
9820 dgst_pos1 = 7;
9821 dgst_pos2 = 2;
9822 dgst_pos3 = 6;
9823 break;
9824
9825 case 10700: hash_type = HASH_TYPE_PDFU32;
9826 salt_type = SALT_TYPE_EMBEDDED;
9827 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9828 opts_type = OPTS_TYPE_PT_GENERATE_LE
9829 | OPTS_TYPE_HASH_COPY;
9830 kern_type = KERN_TYPE_PDF17L8;
9831 dgst_size = DGST_SIZE_4_8;
9832 parse_func = pdf17l8_parse_hash;
9833 sort_by_digest = sort_by_digest_4_8;
9834 opti_type = OPTI_TYPE_ZERO_BYTE
9835 | OPTI_TYPE_NOT_ITERATED;
9836 dgst_pos0 = 0;
9837 dgst_pos1 = 1;
9838 dgst_pos2 = 2;
9839 dgst_pos3 = 3;
9840 break;
9841
9842 case 10800: hash_type = HASH_TYPE_SHA384;
9843 salt_type = SALT_TYPE_NONE;
9844 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9845 opts_type = OPTS_TYPE_PT_GENERATE_BE
9846 | OPTS_TYPE_PT_ADD80
9847 | OPTS_TYPE_PT_ADDBITS15;
9848 kern_type = KERN_TYPE_SHA384;
9849 dgst_size = DGST_SIZE_8_8;
9850 parse_func = sha384_parse_hash;
9851 sort_by_digest = sort_by_digest_8_8;
9852 opti_type = OPTI_TYPE_ZERO_BYTE
9853 | OPTI_TYPE_PRECOMPUTE_INIT
9854 | OPTI_TYPE_PRECOMPUTE_MERKLE
9855 | OPTI_TYPE_EARLY_SKIP
9856 | OPTI_TYPE_NOT_ITERATED
9857 | OPTI_TYPE_NOT_SALTED
9858 | OPTI_TYPE_USES_BITS_64
9859 | OPTI_TYPE_RAW_HASH;
9860 dgst_pos0 = 6;
9861 dgst_pos1 = 7;
9862 dgst_pos2 = 4;
9863 dgst_pos3 = 5;
9864 break;
9865
9866 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9867 salt_type = SALT_TYPE_EMBEDDED;
9868 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9869 opts_type = OPTS_TYPE_PT_GENERATE_LE
9870 | OPTS_TYPE_ST_BASE64
9871 | OPTS_TYPE_HASH_COPY;
9872 kern_type = KERN_TYPE_PBKDF2_SHA256;
9873 dgst_size = DGST_SIZE_4_32;
9874 parse_func = pbkdf2_sha256_parse_hash;
9875 sort_by_digest = sort_by_digest_4_32;
9876 opti_type = OPTI_TYPE_ZERO_BYTE;
9877 dgst_pos0 = 0;
9878 dgst_pos1 = 1;
9879 dgst_pos2 = 2;
9880 dgst_pos3 = 3;
9881 break;
9882
9883 case 11000: hash_type = HASH_TYPE_MD5;
9884 salt_type = SALT_TYPE_INTERN;
9885 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9886 opts_type = OPTS_TYPE_PT_GENERATE_LE
9887 | OPTS_TYPE_PT_ADD80;
9888 kern_type = KERN_TYPE_PRESTASHOP;
9889 dgst_size = DGST_SIZE_4_4;
9890 parse_func = prestashop_parse_hash;
9891 sort_by_digest = sort_by_digest_4_4;
9892 opti_type = OPTI_TYPE_ZERO_BYTE
9893 | OPTI_TYPE_PRECOMPUTE_INIT
9894 | OPTI_TYPE_NOT_ITERATED
9895 | OPTI_TYPE_PREPENDED_SALT;
9896 dgst_pos0 = 0;
9897 dgst_pos1 = 3;
9898 dgst_pos2 = 2;
9899 dgst_pos3 = 1;
9900 break;
9901
9902 case 11100: hash_type = HASH_TYPE_MD5;
9903 salt_type = SALT_TYPE_EMBEDDED;
9904 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9905 opts_type = OPTS_TYPE_PT_GENERATE_LE
9906 | OPTS_TYPE_ST_ADD80;
9907 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9908 dgst_size = DGST_SIZE_4_4;
9909 parse_func = postgresql_auth_parse_hash;
9910 sort_by_digest = sort_by_digest_4_4;
9911 opti_type = OPTI_TYPE_ZERO_BYTE
9912 | OPTI_TYPE_PRECOMPUTE_INIT
9913 | OPTI_TYPE_PRECOMPUTE_MERKLE
9914 | OPTI_TYPE_EARLY_SKIP;
9915 dgst_pos0 = 0;
9916 dgst_pos1 = 3;
9917 dgst_pos2 = 2;
9918 dgst_pos3 = 1;
9919 break;
9920
9921 case 11200: hash_type = HASH_TYPE_SHA1;
9922 salt_type = SALT_TYPE_EMBEDDED;
9923 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9924 opts_type = OPTS_TYPE_PT_GENERATE_BE
9925 | OPTS_TYPE_PT_ADD80
9926 | OPTS_TYPE_ST_HEX;
9927 kern_type = KERN_TYPE_MYSQL_AUTH;
9928 dgst_size = DGST_SIZE_4_5;
9929 parse_func = mysql_auth_parse_hash;
9930 sort_by_digest = sort_by_digest_4_5;
9931 opti_type = OPTI_TYPE_ZERO_BYTE
9932 | OPTI_TYPE_EARLY_SKIP;
9933 dgst_pos0 = 3;
9934 dgst_pos1 = 4;
9935 dgst_pos2 = 2;
9936 dgst_pos3 = 1;
9937 break;
9938
9939 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9940 salt_type = SALT_TYPE_EMBEDDED;
9941 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9942 opts_type = OPTS_TYPE_PT_GENERATE_LE
9943 | OPTS_TYPE_ST_HEX
9944 | OPTS_TYPE_ST_ADD80;
9945 kern_type = KERN_TYPE_BITCOIN_WALLET;
9946 dgst_size = DGST_SIZE_4_4;
9947 parse_func = bitcoin_wallet_parse_hash;
9948 sort_by_digest = sort_by_digest_4_4;
9949 opti_type = OPTI_TYPE_ZERO_BYTE;
9950 dgst_pos0 = 0;
9951 dgst_pos1 = 1;
9952 dgst_pos2 = 2;
9953 dgst_pos3 = 3;
9954 break;
9955
9956 case 11400: hash_type = HASH_TYPE_MD5;
9957 salt_type = SALT_TYPE_EMBEDDED;
9958 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9959 opts_type = OPTS_TYPE_PT_GENERATE_LE
9960 | OPTS_TYPE_PT_ADD80
9961 | OPTS_TYPE_HASH_COPY;
9962 kern_type = KERN_TYPE_SIP_AUTH;
9963 dgst_size = DGST_SIZE_4_4;
9964 parse_func = sip_auth_parse_hash;
9965 sort_by_digest = sort_by_digest_4_4;
9966 opti_type = OPTI_TYPE_ZERO_BYTE;
9967 dgst_pos0 = 0;
9968 dgst_pos1 = 3;
9969 dgst_pos2 = 2;
9970 dgst_pos3 = 1;
9971 break;
9972
9973 case 11500: hash_type = HASH_TYPE_CRC32;
9974 salt_type = SALT_TYPE_INTERN;
9975 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9976 opts_type = OPTS_TYPE_PT_GENERATE_LE
9977 | OPTS_TYPE_ST_GENERATE_LE
9978 | OPTS_TYPE_ST_HEX;
9979 kern_type = KERN_TYPE_CRC32;
9980 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9981 parse_func = crc32_parse_hash;
9982 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9983 opti_type = OPTI_TYPE_ZERO_BYTE;
9984 dgst_pos0 = 0;
9985 dgst_pos1 = 1;
9986 dgst_pos2 = 2;
9987 dgst_pos3 = 3;
9988 break;
9989
9990 case 11600: hash_type = HASH_TYPE_AES;
9991 salt_type = SALT_TYPE_EMBEDDED;
9992 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9993 opts_type = OPTS_TYPE_PT_GENERATE_LE
9994 | OPTS_TYPE_PT_NEVERCRACK;
9995 kern_type = KERN_TYPE_SEVEN_ZIP;
9996 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9997 parse_func = seven_zip_parse_hash;
9998 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9999 opti_type = OPTI_TYPE_ZERO_BYTE;
10000 dgst_pos0 = 0;
10001 dgst_pos1 = 1;
10002 dgst_pos2 = 2;
10003 dgst_pos3 = 3;
10004 break;
10005
10006 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10007 salt_type = SALT_TYPE_NONE;
10008 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10009 opts_type = OPTS_TYPE_PT_GENERATE_LE
10010 | OPTS_TYPE_PT_ADD01;
10011 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10012 dgst_size = DGST_SIZE_4_8;
10013 parse_func = gost2012sbog_256_parse_hash;
10014 sort_by_digest = sort_by_digest_4_8;
10015 opti_type = OPTI_TYPE_ZERO_BYTE;
10016 dgst_pos0 = 0;
10017 dgst_pos1 = 1;
10018 dgst_pos2 = 2;
10019 dgst_pos3 = 3;
10020 break;
10021
10022 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10023 salt_type = SALT_TYPE_NONE;
10024 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10025 opts_type = OPTS_TYPE_PT_GENERATE_LE
10026 | OPTS_TYPE_PT_ADD01;
10027 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10028 dgst_size = DGST_SIZE_4_16;
10029 parse_func = gost2012sbog_512_parse_hash;
10030 sort_by_digest = sort_by_digest_4_16;
10031 opti_type = OPTI_TYPE_ZERO_BYTE;
10032 dgst_pos0 = 0;
10033 dgst_pos1 = 1;
10034 dgst_pos2 = 2;
10035 dgst_pos3 = 3;
10036 break;
10037
10038 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10039 salt_type = SALT_TYPE_EMBEDDED;
10040 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10041 opts_type = OPTS_TYPE_PT_GENERATE_LE
10042 | OPTS_TYPE_ST_BASE64
10043 | OPTS_TYPE_HASH_COPY;
10044 kern_type = KERN_TYPE_PBKDF2_MD5;
10045 dgst_size = DGST_SIZE_4_32;
10046 parse_func = pbkdf2_md5_parse_hash;
10047 sort_by_digest = sort_by_digest_4_32;
10048 opti_type = OPTI_TYPE_ZERO_BYTE;
10049 dgst_pos0 = 0;
10050 dgst_pos1 = 1;
10051 dgst_pos2 = 2;
10052 dgst_pos3 = 3;
10053 break;
10054
10055 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10056 salt_type = SALT_TYPE_EMBEDDED;
10057 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10058 opts_type = OPTS_TYPE_PT_GENERATE_LE
10059 | OPTS_TYPE_ST_BASE64
10060 | OPTS_TYPE_HASH_COPY;
10061 kern_type = KERN_TYPE_PBKDF2_SHA1;
10062 dgst_size = DGST_SIZE_4_32;
10063 parse_func = pbkdf2_sha1_parse_hash;
10064 sort_by_digest = sort_by_digest_4_32;
10065 opti_type = OPTI_TYPE_ZERO_BYTE;
10066 dgst_pos0 = 0;
10067 dgst_pos1 = 1;
10068 dgst_pos2 = 2;
10069 dgst_pos3 = 3;
10070 break;
10071
10072 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10073 salt_type = SALT_TYPE_EMBEDDED;
10074 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10075 opts_type = OPTS_TYPE_PT_GENERATE_LE
10076 | OPTS_TYPE_ST_BASE64
10077 | OPTS_TYPE_HASH_COPY;
10078 kern_type = KERN_TYPE_PBKDF2_SHA512;
10079 dgst_size = DGST_SIZE_8_16;
10080 parse_func = pbkdf2_sha512_parse_hash;
10081 sort_by_digest = sort_by_digest_8_16;
10082 opti_type = OPTI_TYPE_ZERO_BYTE
10083 | OPTI_TYPE_USES_BITS_64;
10084 dgst_pos0 = 0;
10085 dgst_pos1 = 1;
10086 dgst_pos2 = 2;
10087 dgst_pos3 = 3;
10088 break;
10089
10090 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10091 salt_type = SALT_TYPE_EMBEDDED;
10092 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10093 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10094 kern_type = KERN_TYPE_ECRYPTFS;
10095 dgst_size = DGST_SIZE_8_8;
10096 parse_func = ecryptfs_parse_hash;
10097 sort_by_digest = sort_by_digest_8_8;
10098 opti_type = OPTI_TYPE_ZERO_BYTE
10099 | OPTI_TYPE_USES_BITS_64;
10100 dgst_pos0 = 0;
10101 dgst_pos1 = 1;
10102 dgst_pos2 = 2;
10103 dgst_pos3 = 3;
10104 break;
10105
10106 case 12300: hash_type = HASH_TYPE_ORACLET;
10107 salt_type = SALT_TYPE_EMBEDDED;
10108 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10109 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10110 kern_type = KERN_TYPE_ORACLET;
10111 dgst_size = DGST_SIZE_8_16;
10112 parse_func = oraclet_parse_hash;
10113 sort_by_digest = sort_by_digest_8_16;
10114 opti_type = OPTI_TYPE_ZERO_BYTE
10115 | OPTI_TYPE_USES_BITS_64;
10116 dgst_pos0 = 0;
10117 dgst_pos1 = 1;
10118 dgst_pos2 = 2;
10119 dgst_pos3 = 3;
10120 break;
10121
10122 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10123 salt_type = SALT_TYPE_EMBEDDED;
10124 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10125 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10126 kern_type = KERN_TYPE_BSDICRYPT;
10127 dgst_size = DGST_SIZE_4_4;
10128 parse_func = bsdicrypt_parse_hash;
10129 sort_by_digest = sort_by_digest_4_4;
10130 opti_type = OPTI_TYPE_ZERO_BYTE
10131 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10132 dgst_pos0 = 0;
10133 dgst_pos1 = 1;
10134 dgst_pos2 = 2;
10135 dgst_pos3 = 3;
10136 break;
10137
10138 case 12500: hash_type = HASH_TYPE_RAR3HP;
10139 salt_type = SALT_TYPE_EMBEDDED;
10140 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10141 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10142 kern_type = KERN_TYPE_RAR3;
10143 dgst_size = DGST_SIZE_4_4;
10144 parse_func = rar3hp_parse_hash;
10145 sort_by_digest = sort_by_digest_4_4;
10146 opti_type = OPTI_TYPE_ZERO_BYTE;
10147 dgst_pos0 = 0;
10148 dgst_pos1 = 1;
10149 dgst_pos2 = 2;
10150 dgst_pos3 = 3;
10151 break;
10152
10153 case 12600: hash_type = HASH_TYPE_SHA256;
10154 salt_type = SALT_TYPE_INTERN;
10155 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10156 opts_type = OPTS_TYPE_PT_GENERATE_BE
10157 | OPTS_TYPE_PT_ADD80;
10158 kern_type = KERN_TYPE_CF10;
10159 dgst_size = DGST_SIZE_4_8;
10160 parse_func = cf10_parse_hash;
10161 sort_by_digest = sort_by_digest_4_8;
10162 opti_type = OPTI_TYPE_ZERO_BYTE
10163 | OPTI_TYPE_PRECOMPUTE_INIT
10164 | OPTI_TYPE_EARLY_SKIP
10165 | OPTI_TYPE_NOT_ITERATED;
10166 dgst_pos0 = 3;
10167 dgst_pos1 = 7;
10168 dgst_pos2 = 2;
10169 dgst_pos3 = 6;
10170 break;
10171
10172 case 12700: hash_type = HASH_TYPE_AES;
10173 salt_type = SALT_TYPE_EMBEDDED;
10174 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10175 opts_type = OPTS_TYPE_PT_GENERATE_LE
10176 | OPTS_TYPE_HASH_COPY;
10177 kern_type = KERN_TYPE_MYWALLET;
10178 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10179 parse_func = mywallet_parse_hash;
10180 sort_by_digest = sort_by_digest_4_5;
10181 opti_type = OPTI_TYPE_ZERO_BYTE;
10182 dgst_pos0 = 0;
10183 dgst_pos1 = 1;
10184 dgst_pos2 = 2;
10185 dgst_pos3 = 3;
10186 break;
10187
10188 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10189 salt_type = SALT_TYPE_EMBEDDED;
10190 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10191 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10192 kern_type = KERN_TYPE_MS_DRSR;
10193 dgst_size = DGST_SIZE_4_8;
10194 parse_func = ms_drsr_parse_hash;
10195 sort_by_digest = sort_by_digest_4_8;
10196 opti_type = OPTI_TYPE_ZERO_BYTE;
10197 dgst_pos0 = 0;
10198 dgst_pos1 = 1;
10199 dgst_pos2 = 2;
10200 dgst_pos3 = 3;
10201 break;
10202
10203 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10204 salt_type = SALT_TYPE_EMBEDDED;
10205 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10206 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10207 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10208 dgst_size = DGST_SIZE_4_8;
10209 parse_func = androidfde_samsung_parse_hash;
10210 sort_by_digest = sort_by_digest_4_8;
10211 opti_type = OPTI_TYPE_ZERO_BYTE;
10212 dgst_pos0 = 0;
10213 dgst_pos1 = 1;
10214 dgst_pos2 = 2;
10215 dgst_pos3 = 3;
10216 break;
10217
10218 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10219 salt_type = SALT_TYPE_EMBEDDED;
10220 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10221 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10222 kern_type = KERN_TYPE_RAR5;
10223 dgst_size = DGST_SIZE_4_4;
10224 parse_func = rar5_parse_hash;
10225 sort_by_digest = sort_by_digest_4_4;
10226 opti_type = OPTI_TYPE_ZERO_BYTE;
10227 dgst_pos0 = 0;
10228 dgst_pos1 = 1;
10229 dgst_pos2 = 2;
10230 dgst_pos3 = 3;
10231 break;
10232
10233 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10234 salt_type = SALT_TYPE_EMBEDDED;
10235 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10236 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10237 kern_type = KERN_TYPE_KRB5TGS;
10238 dgst_size = DGST_SIZE_4_4;
10239 parse_func = krb5tgs_parse_hash;
10240 sort_by_digest = sort_by_digest_4_4;
10241 opti_type = OPTI_TYPE_ZERO_BYTE
10242 | OPTI_TYPE_NOT_ITERATED;
10243 dgst_pos0 = 0;
10244 dgst_pos1 = 1;
10245 dgst_pos2 = 2;
10246 dgst_pos3 = 3;
10247 break;
10248
10249 case 13200: hash_type = HASH_TYPE_AES;
10250 salt_type = SALT_TYPE_EMBEDDED;
10251 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10252 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10253 kern_type = KERN_TYPE_AXCRYPT;
10254 dgst_size = DGST_SIZE_4_4;
10255 parse_func = axcrypt_parse_hash;
10256 sort_by_digest = sort_by_digest_4_4;
10257 opti_type = OPTI_TYPE_ZERO_BYTE;
10258 dgst_pos0 = 0;
10259 dgst_pos1 = 1;
10260 dgst_pos2 = 2;
10261 dgst_pos3 = 3;
10262 break;
10263
10264 case 13300: hash_type = HASH_TYPE_SHA1;
10265 salt_type = SALT_TYPE_NONE;
10266 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10267 opts_type = OPTS_TYPE_PT_GENERATE_BE
10268 | OPTS_TYPE_PT_ADD80
10269 | OPTS_TYPE_PT_ADDBITS15;
10270 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10271 dgst_size = DGST_SIZE_4_5;
10272 parse_func = sha1axcrypt_parse_hash;
10273 sort_by_digest = sort_by_digest_4_5;
10274 opti_type = OPTI_TYPE_ZERO_BYTE
10275 | OPTI_TYPE_PRECOMPUTE_INIT
10276 | OPTI_TYPE_EARLY_SKIP
10277 | OPTI_TYPE_NOT_ITERATED
10278 | OPTI_TYPE_NOT_SALTED;
10279 dgst_pos0 = 0;
10280 dgst_pos1 = 4;
10281 dgst_pos2 = 3;
10282 dgst_pos3 = 2;
10283 break;
10284
10285 case 13400: hash_type = HASH_TYPE_AES;
10286 salt_type = SALT_TYPE_EMBEDDED;
10287 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10288 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10289 kern_type = KERN_TYPE_KEEPASS;
10290 dgst_size = DGST_SIZE_4_4;
10291 parse_func = keepass_parse_hash;
10292 sort_by_digest = sort_by_digest_4_4;
10293 opti_type = OPTI_TYPE_ZERO_BYTE;
10294 dgst_pos0 = 0;
10295 dgst_pos1 = 1;
10296 dgst_pos2 = 2;
10297 dgst_pos3 = 3;
10298 break;
10299
10300 default: usage_mini_print (PROGNAME); return (-1);
10301 }
10302
10303 /**
10304 * parser
10305 */
10306
10307 data.parse_func = parse_func;
10308
10309 /**
10310 * misc stuff
10311 */
10312
10313 if (hex_salt)
10314 {
10315 if (salt_type == SALT_TYPE_INTERN)
10316 {
10317 opts_type |= OPTS_TYPE_ST_HEX;
10318 }
10319 else
10320 {
10321 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10322
10323 return (-1);
10324 }
10325 }
10326
10327 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10328 | (salt_type == SALT_TYPE_EXTERN)
10329 | (salt_type == SALT_TYPE_EMBEDDED)
10330 | (salt_type == SALT_TYPE_VIRTUAL));
10331
10332 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10333
10334 data.hash_type = hash_type;
10335 data.attack_mode = attack_mode;
10336 data.attack_kern = attack_kern;
10337 data.attack_exec = attack_exec;
10338 data.kern_type = kern_type;
10339 data.opts_type = opts_type;
10340 data.dgst_size = dgst_size;
10341 data.salt_type = salt_type;
10342 data.isSalted = isSalted;
10343 data.sort_by_digest = sort_by_digest;
10344 data.dgst_pos0 = dgst_pos0;
10345 data.dgst_pos1 = dgst_pos1;
10346 data.dgst_pos2 = dgst_pos2;
10347 data.dgst_pos3 = dgst_pos3;
10348
10349 esalt_size = 0;
10350
10351 switch (hash_mode)
10352 {
10353 case 2500: esalt_size = sizeof (wpa_t); break;
10354 case 5300: esalt_size = sizeof (ikepsk_t); break;
10355 case 5400: esalt_size = sizeof (ikepsk_t); break;
10356 case 5500: esalt_size = sizeof (netntlm_t); break;
10357 case 5600: esalt_size = sizeof (netntlm_t); break;
10358 case 6211: esalt_size = sizeof (tc_t); break;
10359 case 6212: esalt_size = sizeof (tc_t); break;
10360 case 6213: esalt_size = sizeof (tc_t); break;
10361 case 6221: esalt_size = sizeof (tc_t); break;
10362 case 6222: esalt_size = sizeof (tc_t); break;
10363 case 6223: esalt_size = sizeof (tc_t); break;
10364 case 6231: esalt_size = sizeof (tc_t); break;
10365 case 6232: esalt_size = sizeof (tc_t); break;
10366 case 6233: esalt_size = sizeof (tc_t); break;
10367 case 6241: esalt_size = sizeof (tc_t); break;
10368 case 6242: esalt_size = sizeof (tc_t); break;
10369 case 6243: esalt_size = sizeof (tc_t); break;
10370 case 6600: esalt_size = sizeof (agilekey_t); break;
10371 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10372 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10373 case 7300: esalt_size = sizeof (rakp_t); break;
10374 case 7500: esalt_size = sizeof (krb5pa_t); break;
10375 case 8200: esalt_size = sizeof (cloudkey_t); break;
10376 case 8800: esalt_size = sizeof (androidfde_t); break;
10377 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10378 case 9400: esalt_size = sizeof (office2007_t); break;
10379 case 9500: esalt_size = sizeof (office2010_t); break;
10380 case 9600: esalt_size = sizeof (office2013_t); break;
10381 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10382 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10383 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10384 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10385 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10386 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10387 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10388 case 10200: esalt_size = sizeof (cram_md5_t); break;
10389 case 10400: esalt_size = sizeof (pdf_t); break;
10390 case 10410: esalt_size = sizeof (pdf_t); break;
10391 case 10420: esalt_size = sizeof (pdf_t); break;
10392 case 10500: esalt_size = sizeof (pdf_t); break;
10393 case 10600: esalt_size = sizeof (pdf_t); break;
10394 case 10700: esalt_size = sizeof (pdf_t); break;
10395 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10396 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10397 case 11400: esalt_size = sizeof (sip_t); break;
10398 case 11600: esalt_size = sizeof (seven_zip_t); break;
10399 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10400 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10401 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10402 case 13000: esalt_size = sizeof (rar5_t); break;
10403 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10404 case 13400: esalt_size = sizeof (keepass_t); break;
10405 }
10406
10407 data.esalt_size = esalt_size;
10408
10409 /**
10410 * choose dictionary parser
10411 */
10412
10413 if (hash_type == HASH_TYPE_LM)
10414 {
10415 get_next_word_func = get_next_word_lm;
10416 }
10417 else if (opts_type & OPTS_TYPE_PT_UPPER)
10418 {
10419 get_next_word_func = get_next_word_uc;
10420 }
10421 else
10422 {
10423 get_next_word_func = get_next_word_std;
10424 }
10425
10426 /**
10427 * dictstat
10428 */
10429
10430 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10431
10432 #ifdef _POSIX
10433 size_t dictstat_nmemb = 0;
10434 #endif
10435
10436 #ifdef _WIN
10437 uint dictstat_nmemb = 0;
10438 #endif
10439
10440 char dictstat[256] = { 0 };
10441
10442 FILE *dictstat_fp = NULL;
10443
10444 if (keyspace == 0)
10445 {
10446 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
10447
10448 dictstat_fp = fopen (dictstat, "rb");
10449
10450 if (dictstat_fp)
10451 {
10452 #ifdef _POSIX
10453 struct stat tmpstat;
10454
10455 fstat (fileno (dictstat_fp), &tmpstat);
10456 #endif
10457
10458 #ifdef _WIN
10459 struct stat64 tmpstat;
10460
10461 _fstat64 (fileno (dictstat_fp), &tmpstat);
10462 #endif
10463
10464 if (tmpstat.st_mtime < COMPTIME)
10465 {
10466 /* with v0.15 the format changed so we have to ensure user is using a good version
10467 since there is no version-header in the dictstat file */
10468
10469 fclose (dictstat_fp);
10470
10471 unlink (dictstat);
10472 }
10473 else
10474 {
10475 while (!feof (dictstat_fp))
10476 {
10477 dictstat_t d;
10478
10479 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10480
10481 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10482
10483 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10484 {
10485 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10486
10487 return -1;
10488 }
10489 }
10490
10491 fclose (dictstat_fp);
10492 }
10493 }
10494 }
10495
10496 /**
10497 * potfile
10498 */
10499
10500 char potfile[256] = { 0 };
10501
10502 if (potfile_path == NULL)
10503 {
10504 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
10505 }
10506 else
10507 {
10508 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
10509 }
10510
10511 data.pot_fp = NULL;
10512
10513 FILE *out_fp = NULL;
10514 FILE *pot_fp = NULL;
10515
10516 if (show == 1 || left == 1)
10517 {
10518 pot_fp = fopen (potfile, "rb");
10519
10520 if (pot_fp == NULL)
10521 {
10522 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10523
10524 return (-1);
10525 }
10526
10527 if (outfile != NULL)
10528 {
10529 if ((out_fp = fopen (outfile, "ab")) == NULL)
10530 {
10531 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10532
10533 fclose (pot_fp);
10534
10535 return (-1);
10536 }
10537 }
10538 else
10539 {
10540 out_fp = stdout;
10541 }
10542 }
10543 else
10544 {
10545 if (potfile_disable == 0)
10546 {
10547 pot_fp = fopen (potfile, "ab");
10548
10549 if (pot_fp == NULL)
10550 {
10551 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10552
10553 return (-1);
10554 }
10555
10556 data.pot_fp = pot_fp;
10557 }
10558 }
10559
10560 pot_t *pot = NULL;
10561
10562 uint pot_cnt = 0;
10563 uint pot_avail = 0;
10564
10565 if (show == 1 || left == 1)
10566 {
10567 SUPPRESS_OUTPUT = 1;
10568
10569 pot_avail = count_lines (pot_fp);
10570
10571 rewind (pot_fp);
10572
10573 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10574
10575 uint pot_hashes_avail = 0;
10576
10577 uint line_num = 0;
10578
10579 char *line_buf = (char *) mymalloc (HCBUFSIZ);
10580
10581 while (!feof (pot_fp))
10582 {
10583 line_num++;
10584
10585 int line_len = fgetl (pot_fp, line_buf);
10586
10587 if (line_len == 0) continue;
10588
10589 char *plain_buf = line_buf + line_len;
10590
10591 pot_t *pot_ptr = &pot[pot_cnt];
10592
10593 hash_t *hashes_buf = &pot_ptr->hash;
10594
10595 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10596 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10597
10598 if (pot_cnt == pot_hashes_avail)
10599 {
10600 uint pos = 0;
10601
10602 for (pos = 0; pos < INCR_POT; pos++)
10603 {
10604 if ((pot_cnt + pos) >= pot_avail) break;
10605
10606 pot_t *tmp_pot = &pot[pot_cnt + pos];
10607
10608 hash_t *tmp_hash = &tmp_pot->hash;
10609
10610 tmp_hash->digest = mymalloc (dgst_size);
10611
10612 if (isSalted)
10613 {
10614 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10615 }
10616
10617 if (esalt_size)
10618 {
10619 tmp_hash->esalt = mymalloc (esalt_size);
10620 }
10621
10622 pot_hashes_avail++;
10623 }
10624 }
10625
10626 int plain_len = 0;
10627
10628 int parser_status;
10629
10630 int iter = MAX_CUT_TRIES;
10631
10632 do
10633 {
10634 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10635 {
10636 if (line_buf[i] == ':')
10637 {
10638 line_len--;
10639
10640 break;
10641 }
10642 }
10643
10644 if (data.hash_mode != 2500)
10645 {
10646 parser_status = parse_func (line_buf, line_len, hashes_buf);
10647 }
10648 else
10649 {
10650 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10651
10652 if (line_len > max_salt_size)
10653 {
10654 parser_status = PARSER_GLOBAL_LENGTH;
10655 }
10656 else
10657 {
10658 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10659
10660 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10661
10662 hashes_buf->salt->salt_len = line_len;
10663
10664 parser_status = PARSER_OK;
10665 }
10666 }
10667
10668 // if NOT parsed without error, we add the ":" to the plain
10669
10670 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10671 {
10672 plain_len++;
10673 plain_buf--;
10674 }
10675
10676 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10677
10678 if (parser_status < PARSER_GLOBAL_ZERO)
10679 {
10680 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10681
10682 continue;
10683 }
10684
10685 if (plain_len >= 255) continue;
10686
10687 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10688
10689 pot_ptr->plain_len = plain_len;
10690
10691 pot_cnt++;
10692 }
10693
10694 myfree (line_buf);
10695
10696 fclose (pot_fp);
10697
10698 SUPPRESS_OUTPUT = 0;
10699
10700 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10701 }
10702
10703 /**
10704 * word len
10705 */
10706
10707 uint pw_min = PW_MIN;
10708 uint pw_max = PW_MAX;
10709
10710 switch (hash_mode)
10711 {
10712 case 125: if (pw_max > 32) pw_max = 32;
10713 break;
10714 case 400: if (pw_max > 40) pw_max = 40;
10715 break;
10716 case 500: if (pw_max > 16) pw_max = 16;
10717 break;
10718 case 1500: if (pw_max > 8) pw_max = 8;
10719 break;
10720 case 1600: if (pw_max > 16) pw_max = 16;
10721 break;
10722 case 1800: if (pw_max > 16) pw_max = 16;
10723 break;
10724 case 2100: if (pw_max > 16) pw_max = 16;
10725 break;
10726 case 2500: if (pw_min < 8) pw_min = 8;
10727 break;
10728 case 3000: if (pw_max > 7) pw_max = 7;
10729 break;
10730 case 5200: if (pw_max > 24) pw_max = 24;
10731 break;
10732 case 5800: if (pw_max > 16) pw_max = 16;
10733 break;
10734 case 6300: if (pw_max > 16) pw_max = 16;
10735 break;
10736 case 7400: if (pw_max > 16) pw_max = 16;
10737 break;
10738 case 7900: if (pw_max > 48) pw_max = 48;
10739 break;
10740 case 8500: if (pw_max > 8) pw_max = 8;
10741 break;
10742 case 8600: if (pw_max > 16) pw_max = 16;
10743 break;
10744 case 9710: pw_min = 5;
10745 pw_max = 5;
10746 break;
10747 case 9810: pw_min = 5;
10748 pw_max = 5;
10749 break;
10750 case 10410: pw_min = 5;
10751 pw_max = 5;
10752 break;
10753 case 10300: if (pw_max < 3) pw_min = 3;
10754 if (pw_max > 40) pw_max = 40;
10755 break;
10756 case 10500: if (pw_max < 3) pw_min = 3;
10757 if (pw_max > 40) pw_max = 40;
10758 break;
10759 case 10700: if (pw_max > 16) pw_max = 16;
10760 break;
10761 case 11300: if (pw_max > 40) pw_max = 40;
10762 break;
10763 case 12500: if (pw_max > 20) pw_max = 20;
10764 break;
10765 case 12800: if (pw_max > 24) pw_max = 24;
10766 break;
10767 }
10768
10769 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10770 {
10771 switch (attack_kern)
10772 {
10773 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10774 break;
10775 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10776 break;
10777 }
10778 }
10779
10780 /**
10781 * charsets : keep them together for more easy maintainnce
10782 */
10783
10784 cs_t mp_sys[6] = { { { 0 }, 0 } };
10785 cs_t mp_usr[4] = { { { 0 }, 0 } };
10786
10787 mp_setup_sys (mp_sys);
10788
10789 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10790 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10791 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10792 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10793
10794 /**
10795 * load hashes, part I: find input mode, count hashes
10796 */
10797
10798 uint hashlist_mode = 0;
10799 uint hashlist_format = HLFMT_HASHCAT;
10800
10801 uint hashes_avail = 0;
10802
10803 if (benchmark == 0)
10804 {
10805 struct stat f;
10806
10807 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10808
10809 if ((hash_mode == 2500) ||
10810 (hash_mode == 5200) ||
10811 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10812 (hash_mode == 9000))
10813 {
10814 hashlist_mode = HL_MODE_ARG;
10815
10816 char *hashfile = myargv[optind];
10817
10818 data.hashfile = hashfile;
10819
10820 logfile_top_var_string ("target", hashfile);
10821 }
10822
10823 if (hashlist_mode == HL_MODE_ARG)
10824 {
10825 if (hash_mode == 2500)
10826 {
10827 struct stat st;
10828
10829 if (stat (data.hashfile, &st) == -1)
10830 {
10831 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10832
10833 return (-1);
10834 }
10835
10836 hashes_avail = st.st_size / sizeof (hccap_t);
10837 }
10838 else
10839 {
10840 hashes_avail = 1;
10841 }
10842 }
10843 else if (hashlist_mode == HL_MODE_FILE)
10844 {
10845 char *hashfile = myargv[optind];
10846
10847 data.hashfile = hashfile;
10848
10849 logfile_top_var_string ("target", hashfile);
10850
10851 FILE *fp = NULL;
10852
10853 if ((fp = fopen (hashfile, "rb")) == NULL)
10854 {
10855 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10856
10857 return (-1);
10858 }
10859
10860 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10861
10862 hashes_avail = count_lines (fp);
10863
10864 rewind (fp);
10865
10866 if (hashes_avail == 0)
10867 {
10868 log_error ("ERROR: hashfile is empty or corrupt");
10869
10870 fclose (fp);
10871
10872 return (-1);
10873 }
10874
10875 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10876
10877 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10878 {
10879 log_error ("ERROR: remove not supported in native hashfile-format mode");
10880
10881 fclose (fp);
10882
10883 return (-1);
10884 }
10885
10886 fclose (fp);
10887 }
10888 }
10889 else
10890 {
10891 hashlist_mode = HL_MODE_ARG;
10892
10893 hashes_avail = 1;
10894 }
10895
10896 if (hash_mode == 3000) hashes_avail *= 2;
10897
10898 data.hashlist_mode = hashlist_mode;
10899 data.hashlist_format = hashlist_format;
10900
10901 logfile_top_uint (hashlist_mode);
10902 logfile_top_uint (hashlist_format);
10903
10904 /**
10905 * load hashes, part II: allocate required memory, set pointers
10906 */
10907
10908 hash_t *hashes_buf = NULL;
10909 void *digests_buf = NULL;
10910 salt_t *salts_buf = NULL;
10911 void *esalts_buf = NULL;
10912
10913 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10914
10915 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10916
10917 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10918 {
10919 u32 hash_pos;
10920
10921 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10922 {
10923 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10924
10925 hashes_buf[hash_pos].hash_info = hash_info;
10926
10927 if (username && (remove || show || left))
10928 {
10929 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10930 }
10931
10932 if (benchmark)
10933 {
10934 hash_info->orighash = (char *) mymalloc (256);
10935 }
10936 }
10937 }
10938
10939 if (isSalted)
10940 {
10941 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10942
10943 if (esalt_size)
10944 {
10945 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10946 }
10947 }
10948 else
10949 {
10950 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10951 }
10952
10953 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10954 {
10955 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10956
10957 if (isSalted)
10958 {
10959 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10960
10961 if (esalt_size)
10962 {
10963 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10964 }
10965 }
10966 else
10967 {
10968 hashes_buf[hash_pos].salt = &salts_buf[0];
10969 }
10970 }
10971
10972 /**
10973 * load hashes, part III: parse hashes or generate them if benchmark
10974 */
10975
10976 uint hashes_cnt = 0;
10977
10978 if (benchmark == 0)
10979 {
10980 if (keyspace == 1)
10981 {
10982 // useless to read hash file for keyspace, cheat a little bit w/ optind
10983 }
10984 else if (hashes_avail == 0)
10985 {
10986 }
10987 else if (hashlist_mode == HL_MODE_ARG)
10988 {
10989 char *input_buf = myargv[optind];
10990
10991 uint input_len = strlen (input_buf);
10992
10993 logfile_top_var_string ("target", input_buf);
10994
10995 char *hash_buf = NULL;
10996 int hash_len = 0;
10997
10998 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10999
11000 bool hash_fmt_error = 0;
11001
11002 if (hash_len < 1) hash_fmt_error = 1;
11003 if (hash_buf == NULL) hash_fmt_error = 1;
11004
11005 if (hash_fmt_error)
11006 {
11007 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11008 }
11009 else
11010 {
11011 if (opts_type & OPTS_TYPE_HASH_COPY)
11012 {
11013 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11014
11015 hash_info_tmp->orighash = mystrdup (hash_buf);
11016 }
11017
11018 if (isSalted)
11019 {
11020 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11021 }
11022
11023 int parser_status = PARSER_OK;
11024
11025 if (hash_mode == 2500)
11026 {
11027 if (hash_len == 0)
11028 {
11029 log_error ("ERROR: hccap file not specified");
11030
11031 return (-1);
11032 }
11033
11034 hashlist_mode = HL_MODE_FILE;
11035
11036 data.hashlist_mode = hashlist_mode;
11037
11038 FILE *fp = fopen (hash_buf, "rb");
11039
11040 if (fp == NULL)
11041 {
11042 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11043
11044 return (-1);
11045 }
11046
11047 if (hashes_avail < 1)
11048 {
11049 log_error ("ERROR: hccap file is empty or corrupt");
11050
11051 fclose (fp);
11052
11053 return (-1);
11054 }
11055
11056 uint hccap_size = sizeof (hccap_t);
11057
11058 char *in = (char *) mymalloc (hccap_size);
11059
11060 while (!feof (fp))
11061 {
11062 int n = fread (in, hccap_size, 1, fp);
11063
11064 if (n != 1)
11065 {
11066 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11067
11068 break;
11069 }
11070
11071 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11072
11073 if (parser_status != PARSER_OK)
11074 {
11075 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11076
11077 continue;
11078 }
11079
11080 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11081
11082 if ((show == 1) || (left == 1))
11083 {
11084 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11085
11086 char *salt_ptr = (char *) tmp_salt->salt_buf;
11087
11088 int cur_pos = tmp_salt->salt_len;
11089 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11090
11091 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11092
11093 // do the appending task
11094
11095 snprintf (salt_ptr + cur_pos,
11096 rem_len,
11097 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11098 wpa->orig_mac1[0],
11099 wpa->orig_mac1[1],
11100 wpa->orig_mac1[2],
11101 wpa->orig_mac1[3],
11102 wpa->orig_mac1[4],
11103 wpa->orig_mac1[5],
11104 wpa->orig_mac2[0],
11105 wpa->orig_mac2[1],
11106 wpa->orig_mac2[2],
11107 wpa->orig_mac2[3],
11108 wpa->orig_mac2[4],
11109 wpa->orig_mac2[5]);
11110
11111 // memset () the remaining part of the salt
11112
11113 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11114 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11115
11116 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11117
11118 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11119 }
11120
11121 if (show == 1) handle_show_request (pot, pot_cnt, (char *) hashes_buf[hashes_cnt].salt->salt_buf, hashes_buf[hashes_cnt].salt->salt_len, &hashes_buf[hashes_cnt], sort_by_salt_buf, out_fp);
11122 if (left == 1) handle_left_request (pot, pot_cnt, (char *) hashes_buf[hashes_cnt].salt->salt_buf, hashes_buf[hashes_cnt].salt->salt_len, &hashes_buf[hashes_cnt], sort_by_salt_buf, out_fp);
11123
11124 hashes_cnt++;
11125 }
11126
11127 fclose (fp);
11128
11129 myfree (in);
11130 }
11131 else if (hash_mode == 3000)
11132 {
11133 if (hash_len == 32)
11134 {
11135 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11136
11137 hash_t *lm_hash_left = NULL;
11138
11139 if (parser_status == PARSER_OK)
11140 {
11141 lm_hash_left = &hashes_buf[hashes_cnt];
11142
11143 hashes_cnt++;
11144 }
11145 else
11146 {
11147 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11148 }
11149
11150 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11151
11152 hash_t *lm_hash_right = NULL;
11153
11154 if (parser_status == PARSER_OK)
11155 {
11156 lm_hash_right = &hashes_buf[hashes_cnt];
11157
11158 hashes_cnt++;
11159 }
11160 else
11161 {
11162 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11163 }
11164
11165 // show / left
11166
11167 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11168 {
11169 if (show == 1) handle_show_request_lm (pot, pot_cnt, input_buf, input_len, lm_hash_left, lm_hash_right, sort_by_pot, out_fp);
11170 if (left == 1) handle_left_request_lm (pot, pot_cnt, input_buf, input_len, lm_hash_left, lm_hash_right, sort_by_pot, out_fp);
11171 }
11172 }
11173 else
11174 {
11175 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11176
11177 if (parser_status == PARSER_OK)
11178 {
11179 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11180 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11181 }
11182
11183 if (parser_status == PARSER_OK)
11184 {
11185 hashes_cnt++;
11186 }
11187 else
11188 {
11189 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11190 }
11191 }
11192 }
11193 else
11194 {
11195 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11196
11197 if (parser_status == PARSER_OK)
11198 {
11199 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11200 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11201 }
11202
11203 if (parser_status == PARSER_OK)
11204 {
11205 hashes_cnt++;
11206 }
11207 else
11208 {
11209 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11210 }
11211 }
11212 }
11213 }
11214 else if (hashlist_mode == HL_MODE_FILE)
11215 {
11216 char *hashfile = data.hashfile;
11217
11218 FILE *fp;
11219
11220 if ((fp = fopen (hashfile, "rb")) == NULL)
11221 {
11222 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11223
11224 return (-1);
11225 }
11226
11227 uint line_num = 0;
11228
11229 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11230
11231 while (!feof (fp))
11232 {
11233 line_num++;
11234
11235 int line_len = fgetl (fp, line_buf);
11236
11237 if (line_len == 0) continue;
11238
11239 char *hash_buf = NULL;
11240 int hash_len = 0;
11241
11242 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11243
11244 bool hash_fmt_error = 0;
11245
11246 if (hash_len < 1) hash_fmt_error = 1;
11247 if (hash_buf == NULL) hash_fmt_error = 1;
11248
11249 if (hash_fmt_error)
11250 {
11251 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11252
11253 continue;
11254 }
11255
11256 if (username)
11257 {
11258 char *user_buf = NULL;
11259 int user_len = 0;
11260
11261 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11262
11263 if (remove || show)
11264 {
11265 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11266
11267 *user = (user_t *) mymalloc (sizeof (user_t));
11268
11269 user_t *user_ptr = *user;
11270
11271 if (user_buf != NULL)
11272 {
11273 user_ptr->user_name = mystrdup (user_buf);
11274 }
11275 else
11276 {
11277 user_ptr->user_name = mystrdup ("");
11278 }
11279
11280 user_ptr->user_len = user_len;
11281 }
11282 }
11283
11284 if (opts_type & OPTS_TYPE_HASH_COPY)
11285 {
11286 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11287
11288 hash_info_tmp->orighash = mystrdup (hash_buf);
11289 }
11290
11291 if (isSalted)
11292 {
11293 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11294 }
11295
11296 if (hash_mode == 3000)
11297 {
11298 if (hash_len == 32)
11299 {
11300 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11301
11302 if (parser_status < PARSER_GLOBAL_ZERO)
11303 {
11304 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11305
11306 continue;
11307 }
11308
11309 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11310
11311 hashes_cnt++;
11312
11313 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11314
11315 if (parser_status < PARSER_GLOBAL_ZERO)
11316 {
11317 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11318
11319 continue;
11320 }
11321
11322 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11323
11324 if (data.quiet == 0) if ((hashes_cnt % 0x20000) == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_cnt, hashes_avail, ((float) hashes_cnt / hashes_avail) * 100);
11325
11326 hashes_cnt++;
11327
11328 // show / left
11329
11330 if (show == 1) handle_show_request_lm (pot, pot_cnt, line_buf, line_len, lm_hash_left, lm_hash_right, sort_by_pot, out_fp);
11331 if (left == 1) handle_left_request_lm (pot, pot_cnt, line_buf, line_len, lm_hash_left, lm_hash_right, sort_by_pot, out_fp);
11332 }
11333 else
11334 {
11335 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11336
11337 if (parser_status < PARSER_GLOBAL_ZERO)
11338 {
11339 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11340
11341 continue;
11342 }
11343
11344 if (data.quiet == 0) if ((hashes_cnt % 0x20000) == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_cnt, hashes_avail, ((float) hashes_cnt / hashes_avail) * 100);
11345
11346 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11347 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11348
11349 hashes_cnt++;
11350 }
11351 }
11352 else
11353 {
11354 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11355
11356 if (parser_status < PARSER_GLOBAL_ZERO)
11357 {
11358 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11359
11360 continue;
11361 }
11362
11363 if (data.quiet == 0) if ((hashes_cnt % 0x20000) == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_cnt, hashes_avail, ((float) hashes_cnt / hashes_avail) * 100);
11364
11365 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11366 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11367
11368 hashes_cnt++;
11369 }
11370 }
11371
11372 myfree (line_buf);
11373
11374 fclose (fp);
11375
11376 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11377
11378 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11379 }
11380 }
11381 else
11382 {
11383 if (isSalted)
11384 {
11385 hashes_buf[0].salt->salt_len = 8;
11386
11387 // special salt handling
11388
11389 switch (hash_mode)
11390 {
11391 case 1500: hashes_buf[0].salt->salt_len = 2;
11392 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
11393 break;
11394 case 1731: hashes_buf[0].salt->salt_len = 4;
11395 break;
11396 case 2410: hashes_buf[0].salt->salt_len = 4;
11397 break;
11398 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11399 break;
11400 case 3100: hashes_buf[0].salt->salt_len = 1;
11401 break;
11402 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11403 break;
11404 case 5800: hashes_buf[0].salt->salt_len = 16;
11405 break;
11406 case 6800: hashes_buf[0].salt->salt_len = 32;
11407 break;
11408 case 8400: hashes_buf[0].salt->salt_len = 40;
11409 break;
11410 case 8800: hashes_buf[0].salt->salt_len = 16;
11411 break;
11412 case 8900: hashes_buf[0].salt->salt_len = 16;
11413 hashes_buf[0].salt->scrypt_N = 1024;
11414 hashes_buf[0].salt->scrypt_r = 1;
11415 hashes_buf[0].salt->scrypt_p = 1;
11416 break;
11417 case 9100: hashes_buf[0].salt->salt_len = 16;
11418 break;
11419 case 9300: hashes_buf[0].salt->salt_len = 14;
11420 hashes_buf[0].salt->scrypt_N = 16384;
11421 hashes_buf[0].salt->scrypt_r = 1;
11422 hashes_buf[0].salt->scrypt_p = 1;
11423 break;
11424 case 9400: hashes_buf[0].salt->salt_len = 16;
11425 break;
11426 case 9500: hashes_buf[0].salt->salt_len = 16;
11427 break;
11428 case 9600: hashes_buf[0].salt->salt_len = 16;
11429 break;
11430 case 9700: hashes_buf[0].salt->salt_len = 16;
11431 break;
11432 case 9710: hashes_buf[0].salt->salt_len = 16;
11433 break;
11434 case 9720: hashes_buf[0].salt->salt_len = 16;
11435 break;
11436 case 9800: hashes_buf[0].salt->salt_len = 16;
11437 break;
11438 case 9810: hashes_buf[0].salt->salt_len = 16;
11439 break;
11440 case 9820: hashes_buf[0].salt->salt_len = 16;
11441 break;
11442 case 10300: hashes_buf[0].salt->salt_len = 12;
11443 break;
11444 case 11500: hashes_buf[0].salt->salt_len = 4;
11445 break;
11446 case 11600: hashes_buf[0].salt->salt_len = 4;
11447 break;
11448 case 12400: hashes_buf[0].salt->salt_len = 4;
11449 break;
11450 case 12500: hashes_buf[0].salt->salt_len = 8;
11451 break;
11452 case 12600: hashes_buf[0].salt->salt_len = 64;
11453 break;
11454 }
11455
11456 // special esalt handling
11457
11458 switch (hash_mode)
11459 {
11460 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11461 break;
11462 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11463 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11464 break;
11465 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11466 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11467 break;
11468 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11469 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11470 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11471 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11472 break;
11473 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11474 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11475 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11476 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11477 break;
11478 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11479 break;
11480 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11481 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11482 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11483 break;
11484 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11485 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11486 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11487 break;
11488 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11489 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11490 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11491 break;
11492 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11493 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11494 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11495 break;
11496 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11497 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11498 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11499 break;
11500 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11501 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11502 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11503 break;
11504 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11505 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11506 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11507 break;
11508 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
11509 break;
11510 }
11511 }
11512
11513 // set hashfile
11514
11515 switch (hash_mode)
11516 {
11517 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11518 break;
11519 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11520 break;
11521 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11522 break;
11523 case 6211: data.hashfile = mystrdup ("hashcat.tc");
11524 break;
11525 case 6212: data.hashfile = mystrdup ("hashcat.tc");
11526 break;
11527 case 6213: data.hashfile = mystrdup ("hashcat.tc");
11528 break;
11529 case 6221: data.hashfile = mystrdup ("hashcat.tc");
11530 break;
11531 case 6222: data.hashfile = mystrdup ("hashcat.tc");
11532 break;
11533 case 6223: data.hashfile = mystrdup ("hashcat.tc");
11534 break;
11535 case 6231: data.hashfile = mystrdup ("hashcat.tc");
11536 break;
11537 case 6232: data.hashfile = mystrdup ("hashcat.tc");
11538 break;
11539 case 6233: data.hashfile = mystrdup ("hashcat.tc");
11540 break;
11541 case 6241: data.hashfile = mystrdup ("hashcat.tc");
11542 break;
11543 case 6242: data.hashfile = mystrdup ("hashcat.tc");
11544 break;
11545 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11546 break;
11547 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11548 break;
11549 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11550 break;
11551 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11552 break;
11553 }
11554
11555 // set default iterations
11556
11557 switch (hash_mode)
11558 {
11559 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11560 break;
11561 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11562 break;
11563 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11564 break;
11565 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11566 break;
11567 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11568 break;
11569 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11570 break;
11571 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11572 break;
11573 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11574 break;
11575 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11576 break;
11577 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11578 break;
11579 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11580 break;
11581 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11582 break;
11583 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11584 break;
11585 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11586 break;
11587 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11588 break;
11589 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11590 break;
11591 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11592 break;
11593 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11594 break;
11595 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11596 break;
11597 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11598 break;
11599 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11600 break;
11601 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11602 break;
11603 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11604 break;
11605 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11606 break;
11607 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11608 break;
11609 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11610 break;
11611 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11612 break;
11613 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11614 break;
11615 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11616 break;
11617 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11618 break;
11619 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11620 break;
11621 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11622 break;
11623 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11624 break;
11625 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11626 break;
11627 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11628 break;
11629 case 8900: hashes_buf[0].salt->salt_iter = 1;
11630 break;
11631 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11632 break;
11633 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11634 break;
11635 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11636 break;
11637 case 9300: hashes_buf[0].salt->salt_iter = 1;
11638 break;
11639 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11640 break;
11641 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11642 break;
11643 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11644 break;
11645 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11646 break;
11647 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11648 break;
11649 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11650 break;
11651 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11652 break;
11653 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11654 break;
11655 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11656 break;
11657 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11658 break;
11659 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11660 break;
11661 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11662 break;
11663 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11664 break;
11665 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11666 break;
11667 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11668 break;
11669 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11670 break;
11671 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11672 break;
11673 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11674 break;
11675 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11676 break;
11677 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11678 break;
11679 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11680 break;
11681 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
11682 break;
11683 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
11684 break;
11685 }
11686
11687 hashes_cnt = 1;
11688 }
11689
11690 if (show == 1 || left == 1)
11691 {
11692 for (uint i = 0; i < pot_cnt; i++)
11693 {
11694 pot_t *pot_ptr = &pot[i];
11695
11696 hash_t *hashes_buf = &pot_ptr->hash;
11697
11698 local_free (hashes_buf->digest);
11699
11700 if (isSalted)
11701 {
11702 local_free (hashes_buf->salt);
11703 }
11704 }
11705
11706 local_free (pot);
11707
11708 if (data.quiet == 0) log_info_nn ("");
11709
11710 return (0);
11711 }
11712
11713 if (keyspace == 0)
11714 {
11715 if (hashes_cnt == 0)
11716 {
11717 log_error ("ERROR: No hashes loaded");
11718
11719 return (-1);
11720 }
11721 }
11722
11723 /**
11724 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11725 */
11726
11727 if (data.outfile != NULL)
11728 {
11729 if (data.hashfile != NULL)
11730 {
11731 #ifdef _POSIX
11732 struct stat tmpstat_outfile;
11733 struct stat tmpstat_hashfile;
11734 #endif
11735
11736 #ifdef _WIN
11737 struct stat64 tmpstat_outfile;
11738 struct stat64 tmpstat_hashfile;
11739 #endif
11740
11741 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11742
11743 if (tmp_outfile_fp)
11744 {
11745 #ifdef _POSIX
11746 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11747 #endif
11748
11749 #ifdef _WIN
11750 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11751 #endif
11752
11753 fclose (tmp_outfile_fp);
11754 }
11755
11756 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11757
11758 if (tmp_hashfile_fp)
11759 {
11760 #ifdef _POSIX
11761 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11762 #endif
11763
11764 #ifdef _WIN
11765 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11766 #endif
11767
11768 fclose (tmp_hashfile_fp);
11769 }
11770
11771 if (tmp_outfile_fp && tmp_outfile_fp)
11772 {
11773 tmpstat_outfile.st_mode = 0;
11774 tmpstat_outfile.st_nlink = 0;
11775 tmpstat_outfile.st_uid = 0;
11776 tmpstat_outfile.st_gid = 0;
11777 tmpstat_outfile.st_rdev = 0;
11778 tmpstat_outfile.st_atime = 0;
11779
11780 tmpstat_hashfile.st_mode = 0;
11781 tmpstat_hashfile.st_nlink = 0;
11782 tmpstat_hashfile.st_uid = 0;
11783 tmpstat_hashfile.st_gid = 0;
11784 tmpstat_hashfile.st_rdev = 0;
11785 tmpstat_hashfile.st_atime = 0;
11786
11787 #ifdef _POSIX
11788 tmpstat_outfile.st_blksize = 0;
11789 tmpstat_outfile.st_blocks = 0;
11790
11791 tmpstat_hashfile.st_blksize = 0;
11792 tmpstat_hashfile.st_blocks = 0;
11793 #endif
11794
11795 #ifdef _POSIX
11796 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11797 {
11798 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11799
11800 return (-1);
11801 }
11802 #endif
11803
11804 #ifdef _WIN
11805 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 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 }
11814 }
11815
11816 /**
11817 * Remove duplicates
11818 */
11819
11820 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11821
11822 if (isSalted)
11823 {
11824 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11825 }
11826 else
11827 {
11828 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11829 }
11830
11831 uint hashes_cnt_orig = hashes_cnt;
11832
11833 hashes_cnt = 1;
11834
11835 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11836 {
11837 if (isSalted)
11838 {
11839 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11840 {
11841 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11842 }
11843 }
11844 else
11845 {
11846 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11847 }
11848
11849 if (hashes_pos > hashes_cnt)
11850 {
11851 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11852 }
11853
11854 hashes_cnt++;
11855 }
11856
11857 /**
11858 * Potfile removes
11859 */
11860
11861 uint potfile_remove_cracks = 0;
11862
11863 if (potfile_disable == 0)
11864 {
11865 hash_t hash_buf;
11866
11867 hash_buf.digest = mymalloc (dgst_size);
11868 hash_buf.salt = NULL;
11869 hash_buf.esalt = NULL;
11870 hash_buf.hash_info = NULL;
11871 hash_buf.cracked = 0;
11872
11873 if (isSalted)
11874 {
11875 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11876 }
11877
11878 if (esalt_size)
11879 {
11880 hash_buf.esalt = mymalloc (esalt_size);
11881 }
11882
11883 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11884
11885 // no solution for these special hash types (for instane because they use hashfile in output etc)
11886 if ((hash_mode != 5200) &&
11887 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11888 (hash_mode != 9000))
11889 {
11890 FILE *fp = fopen (potfile, "rb");
11891
11892 if (fp != NULL)
11893 {
11894 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11895
11896 // to be safe work with a copy (because of line_len loop, i etc)
11897 // moved up here because it's easier to handle continue case
11898 // it's just 64kb
11899
11900 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
11901
11902 while (!feof (fp))
11903 {
11904 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
11905
11906 if (ptr == NULL) break;
11907
11908 int line_len = strlen (line_buf);
11909
11910 if (line_len == 0) continue;
11911
11912 int iter = MAX_CUT_TRIES;
11913
11914 for (int i = line_len - 1; i && iter; i--, line_len--)
11915 {
11916 if (line_buf[i] != ':') continue;
11917
11918 if (isSalted)
11919 {
11920 memset (hash_buf.salt, 0, sizeof (salt_t));
11921 }
11922
11923 hash_t *found = NULL;
11924
11925 if (hash_mode == 6800)
11926 {
11927 if (i < 64) // 64 = 16 * uint in salt_buf[]
11928 {
11929 // manipulate salt_buf
11930 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11931
11932 hash_buf.salt->salt_len = i;
11933
11934 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11935 }
11936 }
11937 else if (hash_mode == 2500)
11938 {
11939 if (i < 64) // 64 = 16 * uint in salt_buf[]
11940 {
11941 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11942 // manipulate salt_buf
11943
11944 memcpy (line_buf_cpy, line_buf, i);
11945
11946 char *mac2_pos = strrchr (line_buf_cpy, ':');
11947
11948 if (mac2_pos == NULL) continue;
11949
11950 mac2_pos[0] = 0;
11951 mac2_pos++;
11952
11953 if (strlen (mac2_pos) != 12) continue;
11954
11955 char *mac1_pos = strrchr (line_buf_cpy, ':');
11956
11957 if (mac1_pos == NULL) continue;
11958
11959 mac1_pos[0] = 0;
11960 mac1_pos++;
11961
11962 if (strlen (mac1_pos) != 12) continue;
11963
11964 uint essid_length = mac1_pos - line_buf_cpy - 1;
11965
11966 // here we need the ESSID
11967 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11968
11969 hash_buf.salt->salt_len = essid_length;
11970
11971 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11972
11973 if (found)
11974 {
11975 wpa_t *wpa = (wpa_t *) found->esalt;
11976
11977 // compare hex string(s) vs binary MAC address(es)
11978
11979 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11980 {
11981 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
11982 {
11983 found = NULL;
11984
11985 break;
11986 }
11987 }
11988
11989 // early skip ;)
11990 if (!found) continue;
11991
11992 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11993 {
11994 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
11995 {
11996 found = NULL;
11997
11998 break;
11999 }
12000 }
12001 }
12002 }
12003 }
12004 else
12005 {
12006 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12007
12008 if (parser_status == PARSER_OK)
12009 {
12010 if (isSalted)
12011 {
12012 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12013 }
12014 else
12015 {
12016 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12017 }
12018 }
12019 }
12020
12021 if (found == NULL) continue;
12022
12023 if (!found->cracked) potfile_remove_cracks++;
12024
12025 found->cracked = 1;
12026
12027 if (found) break;
12028
12029 iter--;
12030 }
12031 }
12032
12033 myfree (line_buf_cpy);
12034
12035 myfree (line_buf);
12036
12037 fclose (fp);
12038 }
12039 }
12040
12041 if (esalt_size)
12042 {
12043 local_free (hash_buf.esalt);
12044 }
12045
12046 if (isSalted)
12047 {
12048 local_free (hash_buf.salt);
12049 }
12050
12051 local_free (hash_buf.digest);
12052 }
12053
12054 /**
12055 * Now generate all the buffers required for later
12056 */
12057
12058 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12059
12060 salt_t *salts_buf_new = NULL;
12061 void *esalts_buf_new = NULL;
12062
12063 if (isSalted)
12064 {
12065 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12066
12067 if (esalt_size)
12068 {
12069 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12070 }
12071 }
12072 else
12073 {
12074 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12075 }
12076
12077 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12078
12079 uint digests_cnt = hashes_cnt;
12080 uint digests_done = 0;
12081
12082 uint size_digests = digests_cnt * dgst_size;
12083 uint size_shown = digests_cnt * sizeof (uint);
12084
12085 uint *digests_shown = (uint *) mymalloc (size_shown);
12086 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12087
12088 uint salts_cnt = 0;
12089 uint salts_done = 0;
12090
12091 hashinfo_t **hash_info = NULL;
12092
12093 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12094 {
12095 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12096
12097 if (username && (remove || show))
12098 {
12099 uint user_pos;
12100
12101 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12102 {
12103 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12104
12105 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12106 }
12107 }
12108 }
12109
12110 uint *salts_shown = (uint *) mymalloc (size_shown);
12111
12112 salt_t *salt_buf;
12113
12114 {
12115 // copied from inner loop
12116
12117 salt_buf = &salts_buf_new[salts_cnt];
12118
12119 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12120
12121 if (esalt_size)
12122 {
12123 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12124 }
12125
12126 salt_buf->digests_cnt = 0;
12127 salt_buf->digests_done = 0;
12128 salt_buf->digests_offset = 0;
12129
12130 salts_cnt++;
12131 }
12132
12133 if (hashes_buf[0].cracked == 1)
12134 {
12135 digests_shown[0] = 1;
12136
12137 digests_done++;
12138
12139 salt_buf->digests_done++;
12140 }
12141
12142 salt_buf->digests_cnt++;
12143
12144 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12145
12146 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12147 {
12148 hash_info[0] = hashes_buf[0].hash_info;
12149 }
12150
12151 // copy from inner loop
12152
12153 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12154 {
12155 if (isSalted)
12156 {
12157 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12158 {
12159 salt_buf = &salts_buf_new[salts_cnt];
12160
12161 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12162
12163 if (esalt_size)
12164 {
12165 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12166 }
12167
12168 salt_buf->digests_cnt = 0;
12169 salt_buf->digests_done = 0;
12170 salt_buf->digests_offset = hashes_pos;
12171
12172 salts_cnt++;
12173 }
12174 }
12175
12176 if (hashes_buf[hashes_pos].cracked == 1)
12177 {
12178 digests_shown[hashes_pos] = 1;
12179
12180 digests_done++;
12181
12182 salt_buf->digests_done++;
12183 }
12184
12185 salt_buf->digests_cnt++;
12186
12187 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12188
12189 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12190 {
12191 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12192 }
12193 }
12194
12195 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12196 {
12197 salt_t *salt_buf = &salts_buf_new[salt_pos];
12198
12199 if (salt_buf->digests_done == salt_buf->digests_cnt)
12200 {
12201 salts_shown[salt_pos] = 1;
12202
12203 salts_done++;
12204 }
12205
12206 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12207 }
12208
12209 local_free (digests_buf);
12210 local_free (salts_buf);
12211 local_free (esalts_buf);
12212
12213 digests_buf = digests_buf_new;
12214 salts_buf = salts_buf_new;
12215 esalts_buf = esalts_buf_new;
12216
12217 local_free (hashes_buf);
12218
12219 /**
12220 * special modification not set from parser
12221 */
12222
12223 switch (hash_mode)
12224 {
12225 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12226 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12227 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12228 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12229 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12230 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12231 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12232 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12233 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12234 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12235 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12236 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12237 }
12238
12239 if (truecrypt_keyfiles)
12240 {
12241 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12242
12243 char *keyfiles = strdup (truecrypt_keyfiles);
12244
12245 char *keyfile = strtok (keyfiles, ",");
12246
12247 do
12248 {
12249 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12250
12251 } while ((keyfile = strtok (NULL, ",")) != NULL);
12252
12253 free (keyfiles);
12254 }
12255
12256 data.digests_cnt = digests_cnt;
12257 data.digests_done = digests_done;
12258 data.digests_buf = digests_buf;
12259 data.digests_shown = digests_shown;
12260 data.digests_shown_tmp = digests_shown_tmp;
12261
12262 data.salts_cnt = salts_cnt;
12263 data.salts_done = salts_done;
12264 data.salts_buf = salts_buf;
12265 data.salts_shown = salts_shown;
12266
12267 data.esalts_buf = esalts_buf;
12268 data.hash_info = hash_info;
12269
12270 /**
12271 * Automatic Optimizers
12272 */
12273
12274 if (salts_cnt == 1)
12275 opti_type |= OPTI_TYPE_SINGLE_SALT;
12276
12277 if (digests_cnt == 1)
12278 opti_type |= OPTI_TYPE_SINGLE_HASH;
12279
12280 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12281 opti_type |= OPTI_TYPE_NOT_ITERATED;
12282
12283 if (attack_mode == ATTACK_MODE_BF)
12284 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12285
12286 data.opti_type = opti_type;
12287
12288 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12289 {
12290 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12291 {
12292 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12293 {
12294 if (opts_type & OPTS_TYPE_ST_ADD80)
12295 {
12296 opts_type &= ~OPTS_TYPE_ST_ADD80;
12297 opts_type |= OPTS_TYPE_PT_ADD80;
12298 }
12299
12300 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12301 {
12302 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12303 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12304 }
12305
12306 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12307 {
12308 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12309 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12310 }
12311 }
12312 }
12313 }
12314
12315 /**
12316 * Some algorithm, like descrypt, can benefit from JIT compilation
12317 */
12318
12319 int force_jit_compilation = -1;
12320
12321 if (hash_mode == 8900)
12322 {
12323 force_jit_compilation = 8900;
12324 }
12325 else if (hash_mode == 9300)
12326 {
12327 force_jit_compilation = 8900;
12328 }
12329 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12330 {
12331 force_jit_compilation = 1500;
12332 }
12333
12334 /**
12335 * generate bitmap tables
12336 */
12337
12338 const uint bitmap_shift1 = 5;
12339 const uint bitmap_shift2 = 13;
12340
12341 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12342
12343 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12344 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12345 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12346 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12347 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12348 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12349 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12350 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12351
12352 uint bitmap_bits;
12353 uint bitmap_nums;
12354 uint bitmap_mask;
12355 uint bitmap_size;
12356
12357 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12358 {
12359 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12360
12361 bitmap_nums = 1 << bitmap_bits;
12362
12363 bitmap_mask = bitmap_nums - 1;
12364
12365 bitmap_size = bitmap_nums * sizeof (uint);
12366
12367 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12368
12369 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;
12370 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;
12371
12372 break;
12373 }
12374
12375 bitmap_nums = 1 << bitmap_bits;
12376
12377 bitmap_mask = bitmap_nums - 1;
12378
12379 bitmap_size = bitmap_nums * sizeof (uint);
12380
12381 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);
12382 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);
12383
12384 /**
12385 * prepare quick rule
12386 */
12387
12388 data.rule_buf_l = rule_buf_l;
12389 data.rule_buf_r = rule_buf_r;
12390
12391 int rule_len_l = (int) strlen (rule_buf_l);
12392 int rule_len_r = (int) strlen (rule_buf_r);
12393
12394 data.rule_len_l = rule_len_l;
12395 data.rule_len_r = rule_len_r;
12396
12397 /**
12398 * load rules
12399 */
12400
12401 uint *all_kernel_rules_cnt = NULL;
12402
12403 kernel_rule_t **all_kernel_rules_buf = NULL;
12404
12405 if (rp_files_cnt)
12406 {
12407 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12408
12409 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12410 }
12411
12412 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
12413
12414 int rule_len = 0;
12415
12416 for (uint i = 0; i < rp_files_cnt; i++)
12417 {
12418 uint kernel_rules_avail = 0;
12419
12420 uint kernel_rules_cnt = 0;
12421
12422 kernel_rule_t *kernel_rules_buf = NULL;
12423
12424 char *rp_file = rp_files[i];
12425
12426 char in[BLOCK_SIZE] = { 0 };
12427 char out[BLOCK_SIZE] = { 0 };
12428
12429 FILE *fp = NULL;
12430
12431 uint rule_line = 0;
12432
12433 if ((fp = fopen (rp_file, "rb")) == NULL)
12434 {
12435 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12436
12437 return (-1);
12438 }
12439
12440 while (!feof (fp))
12441 {
12442 memset (rule_buf, 0, HCBUFSIZ);
12443
12444 rule_len = fgetl (fp, rule_buf);
12445
12446 rule_line++;
12447
12448 if (rule_len == 0) continue;
12449
12450 if (rule_buf[0] == '#') continue;
12451
12452 if (kernel_rules_avail == kernel_rules_cnt)
12453 {
12454 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12455
12456 kernel_rules_avail += INCR_RULES;
12457 }
12458
12459 memset (in, 0, BLOCK_SIZE);
12460 memset (out, 0, BLOCK_SIZE);
12461
12462 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12463
12464 if (result == -1)
12465 {
12466 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12467
12468 continue;
12469 }
12470
12471 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12472 {
12473 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12474
12475 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12476
12477 continue;
12478 }
12479
12480 /* its so slow
12481 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12482 {
12483 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12484
12485 continue;
12486 }
12487 */
12488
12489 kernel_rules_cnt++;
12490 }
12491
12492 fclose (fp);
12493
12494 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12495
12496 all_kernel_rules_buf[i] = kernel_rules_buf;
12497 }
12498
12499 /**
12500 * merge rules or automatic rule generator
12501 */
12502
12503 uint kernel_rules_cnt = 0;
12504
12505 kernel_rule_t *kernel_rules_buf = NULL;
12506
12507 if (attack_mode == ATTACK_MODE_STRAIGHT)
12508 {
12509 if (rp_files_cnt)
12510 {
12511 kernel_rules_cnt = 1;
12512
12513 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12514
12515 repeats[0] = kernel_rules_cnt;
12516
12517 for (uint i = 0; i < rp_files_cnt; i++)
12518 {
12519 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12520
12521 repeats[i + 1] = kernel_rules_cnt;
12522 }
12523
12524 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12525
12526 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12527
12528 for (uint i = 0; i < kernel_rules_cnt; i++)
12529 {
12530 uint out_pos = 0;
12531
12532 kernel_rule_t *out = &kernel_rules_buf[i];
12533
12534 for (uint j = 0; j < rp_files_cnt; j++)
12535 {
12536 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12537 uint in_pos;
12538
12539 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12540
12541 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12542 {
12543 if (out_pos == RULES_MAX - 1)
12544 {
12545 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12546
12547 break;
12548 }
12549
12550 out->cmds[out_pos] = in->cmds[in_pos];
12551 }
12552 }
12553 }
12554
12555 local_free (repeats);
12556 }
12557 else if (rp_gen)
12558 {
12559 uint kernel_rules_avail = 0;
12560
12561 while (kernel_rules_cnt < rp_gen)
12562 {
12563 if (kernel_rules_avail == kernel_rules_cnt)
12564 {
12565 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12566
12567 kernel_rules_avail += INCR_RULES;
12568 }
12569
12570 memset (rule_buf, 0, HCBUFSIZ);
12571
12572 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12573
12574 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12575
12576 kernel_rules_cnt++;
12577 }
12578 }
12579 }
12580
12581 myfree (rule_buf);
12582
12583 /**
12584 * generate NOP rules
12585 */
12586
12587 if (kernel_rules_cnt == 0)
12588 {
12589 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12590
12591 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12592
12593 kernel_rules_cnt++;
12594 }
12595
12596 data.kernel_rules_cnt = kernel_rules_cnt;
12597 data.kernel_rules_buf = kernel_rules_buf;
12598
12599 /**
12600 * OpenCL platforms: detect
12601 */
12602
12603 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
12604 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
12605
12606 cl_uint platforms_cnt = 0;
12607 cl_uint platform_devices_cnt = 0;
12608
12609 if (keyspace == 0)
12610 {
12611 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12612
12613 if (platforms_cnt == 0)
12614 {
12615 log_error ("ERROR: No OpenCL compatible platform found");
12616
12617 return (-1);
12618 }
12619
12620 if (opencl_platforms_filter != (uint) -1)
12621 {
12622 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
12623
12624 if (opencl_platforms_filter > platform_cnt_mask)
12625 {
12626 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
12627
12628 return (-1);
12629 }
12630 }
12631 }
12632
12633 /**
12634 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12635 */
12636
12637 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12638 {
12639 cl_platform_id platform = platforms[platform_id];
12640
12641 char platform_vendor[INFOSZ] = { 0 };
12642
12643 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12644
12645 #ifdef HAVE_HWMON
12646 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12647 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12648 {
12649 // make sure that we do not directly control the fan for NVidia
12650
12651 gpu_temp_retain = 0;
12652
12653 data.gpu_temp_retain = gpu_temp_retain;
12654 }
12655 #endif // HAVE_NVML || HAVE_NVAPI
12656 #endif
12657 }
12658
12659 /**
12660 * OpenCL devices: simply push all devices from all platforms into the same device array
12661 */
12662
12663 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12664
12665 data.devices_param = devices_param;
12666
12667 uint devices_cnt = 0;
12668
12669 uint devices_active = 0;
12670
12671 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12672 {
12673 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12674
12675 cl_platform_id platform = platforms[platform_id];
12676
12677 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12678
12679 char platform_vendor[INFOSZ] = { 0 };
12680
12681 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12682
12683 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
12684 // this causes trouble with vendor id based macros
12685 // we'll assign generic to those without special optimization available
12686
12687 cl_uint vendor_id = 0;
12688
12689 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
12690 {
12691 vendor_id = VENDOR_ID_AMD;
12692 }
12693 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
12694 {
12695 vendor_id = VENDOR_ID_GENERIC;
12696 }
12697 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
12698 {
12699 vendor_id = VENDOR_ID_GENERIC;
12700 }
12701 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
12702 {
12703 vendor_id = VENDOR_ID_GENERIC;
12704 }
12705 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
12706 {
12707 vendor_id = VENDOR_ID_GENERIC;
12708 }
12709 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12710 {
12711 vendor_id = VENDOR_ID_NV;
12712 }
12713 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
12714 {
12715 vendor_id = VENDOR_ID_GENERIC;
12716 }
12717 else
12718 {
12719 vendor_id = VENDOR_ID_GENERIC;
12720 }
12721
12722 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12723 {
12724 size_t param_value_size = 0;
12725
12726 const uint device_id = devices_cnt;
12727
12728 hc_device_param_t *device_param = &data.devices_param[device_id];
12729
12730 device_param->vendor_id = vendor_id;
12731
12732 device_param->device = platform_devices[platform_devices_id];
12733
12734 device_param->device_id = device_id;
12735
12736 device_param->platform_devices_id = platform_devices_id;
12737
12738 // device_type
12739
12740 cl_device_type device_type;
12741
12742 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12743
12744 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12745
12746 device_param->device_type = device_type;
12747
12748 // device_name
12749
12750 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
12751
12752 char *device_name = (char *) mymalloc (param_value_size);
12753
12754 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
12755
12756 device_param->device_name = device_name;
12757
12758 // tuning db
12759
12760 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
12761
12762 // device_version
12763
12764 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
12765
12766 char *device_version = (char *) mymalloc (param_value_size);
12767
12768 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
12769
12770 device_param->device_version = device_version;
12771
12772 // device_opencl_version
12773
12774 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
12775
12776 char *device_opencl_version = (char *) mymalloc (param_value_size);
12777
12778 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
12779
12780 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
12781
12782 myfree (device_opencl_version);
12783
12784 // vector_width
12785
12786 cl_uint vector_width;
12787
12788 if (opencl_vector_width_chgd == 0)
12789 {
12790 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
12791 {
12792 if (opti_type & OPTI_TYPE_USES_BITS_64)
12793 {
12794 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
12795 }
12796 else
12797 {
12798 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12799 }
12800 }
12801 else
12802 {
12803 vector_width = (cl_uint) tuningdb_entry->vector_width;
12804 }
12805 }
12806 else
12807 {
12808 vector_width = opencl_vector_width;
12809 }
12810
12811 if (vector_width > 16) vector_width = 16;
12812
12813 device_param->vector_width = vector_width;
12814
12815 // max_compute_units
12816
12817 cl_uint device_processors;
12818
12819 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12820
12821 device_param->device_processors = device_processors;
12822
12823 // max_mem_alloc_size
12824
12825 cl_ulong device_maxmem_alloc;
12826
12827 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12828
12829 device_param->device_maxmem_alloc = device_maxmem_alloc;
12830
12831 // max_mem_alloc_size
12832
12833 cl_ulong device_global_mem;
12834
12835 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12836
12837 device_param->device_global_mem = device_global_mem;
12838
12839 // max_clock_frequency
12840
12841 cl_uint device_maxclock_frequency;
12842
12843 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12844
12845 device_param->device_maxclock_frequency = device_maxclock_frequency;
12846
12847 // skipped
12848
12849 const u32 skipped1 = ((devices_filter & (1 << device_id)) == 0);
12850 const u32 skipped2 = ((device_types_filter & (device_type)) == 0);
12851
12852 device_param->skipped = (skipped1 || skipped2);
12853
12854 // driver_version
12855 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
12856
12857 char *driver_version = (char *) mymalloc (param_value_size);
12858
12859 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
12860
12861 device_param->driver_version = driver_version;
12862
12863 // device_name_chksum
12864
12865 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12866
12867 #if __x86_64__
12868 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);
12869 #else
12870 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);
12871 #endif
12872
12873 uint device_name_digest[4] = { 0 };
12874
12875 md5_64 ((uint *) device_name_chksum, device_name_digest);
12876
12877 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
12878
12879 device_param->device_name_chksum = device_name_chksum;
12880
12881 // device_processor_cores
12882
12883 if (device_type & CL_DEVICE_TYPE_CPU)
12884 {
12885 cl_uint device_processor_cores = 1;
12886
12887 device_param->device_processor_cores = device_processor_cores;
12888 }
12889
12890 if (device_type & CL_DEVICE_TYPE_GPU)
12891 {
12892 if (vendor_id == VENDOR_ID_AMD)
12893 {
12894 cl_uint device_processor_cores = 0;
12895
12896 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12897
12898 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12899
12900 device_param->device_processor_cores = device_processor_cores;
12901 }
12902 else if (vendor_id == VENDOR_ID_NV)
12903 {
12904 cl_uint kernel_exec_timeout = 0;
12905
12906 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12907
12908 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12909
12910 device_param->kernel_exec_timeout = kernel_exec_timeout;
12911
12912 cl_uint device_processor_cores = 0;
12913
12914 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12915
12916 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12917
12918 device_param->device_processor_cores = device_processor_cores;
12919
12920 cl_uint sm_minor = 0;
12921 cl_uint sm_major = 0;
12922
12923 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12924 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12925
12926 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12927 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12928
12929 device_param->sm_minor = sm_minor;
12930 device_param->sm_major = sm_major;
12931 }
12932 else
12933 {
12934 cl_uint device_processor_cores = 1;
12935
12936 device_param->device_processor_cores = device_processor_cores;
12937 }
12938 }
12939
12940 // display results
12941
12942 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12943 {
12944 if (device_param->skipped == 0)
12945 {
12946 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12947 device_id + 1,
12948 device_name,
12949 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
12950 (unsigned int) (device_global_mem / 1024 / 1024),
12951 (unsigned int) (device_maxclock_frequency),
12952 (unsigned int) device_processors);
12953 }
12954 else
12955 {
12956 log_info ("Device #%u: %s, skipped",
12957 device_id + 1,
12958 device_name);
12959 }
12960 }
12961
12962 // common driver check
12963
12964 if (device_param->skipped == 0)
12965 {
12966 if (device_type & CL_DEVICE_TYPE_GPU)
12967 {
12968 if (vendor_id == VENDOR_ID_AMD)
12969 {
12970 int catalyst_check = (force == 1) ? 0 : 1;
12971
12972 int catalyst_warn = 0;
12973
12974 int catalyst_broken = 0;
12975
12976 if (catalyst_check == 1)
12977 {
12978 catalyst_warn = 1;
12979
12980 // v14.9 and higher
12981 if (atoi (device_param->driver_version) >= 1573)
12982 {
12983 catalyst_warn = 0;
12984 }
12985
12986 catalyst_check = 0;
12987 }
12988
12989 if (catalyst_broken == 1)
12990 {
12991 log_info ("");
12992 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
12993 log_info ("It will pass over cracked hashes and does not report them as cracked");
12994 log_info ("You are STRONGLY encouraged not to use it");
12995 log_info ("You can use --force to override this but do not post error reports if you do so");
12996 log_info ("");
12997
12998 return (-1);
12999 }
13000
13001 if (catalyst_warn == 1)
13002 {
13003 log_info ("");
13004 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13005 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13006 log_info ("See oclHashcat's homepage for official supported catalyst drivers");
13007 #ifdef _WIN
13008 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13009 #endif
13010 log_info ("You can use --force to override this but do not post error reports if you do so");
13011 log_info ("");
13012
13013 return (-1);
13014 }
13015 }
13016 else if (vendor_id == VENDOR_ID_NV)
13017 {
13018 if (device_param->kernel_exec_timeout != 0)
13019 {
13020 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);
13021 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
13022 }
13023 }
13024 else if (vendor_id == VENDOR_ID_POCL)
13025 {
13026 if (force == 0)
13027 {
13028 log_info ("");
13029 log_info ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
13030 log_info ("You are STRONGLY encouraged not to use it");
13031 log_info ("You can use --force to override this but do not post error reports if you do so");
13032 log_info ("");
13033
13034 return (-1);
13035 }
13036 }
13037 }
13038
13039 /**
13040 * kernel accel and loops tuning db adjustment
13041 */
13042
13043 device_param->kernel_accel_min = 1;
13044 device_param->kernel_accel_max = 1024;
13045
13046 device_param->kernel_loops_min = 1;
13047 device_param->kernel_loops_max = 1024;
13048
13049 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13050
13051 if (tuningdb_entry)
13052 {
13053 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13054 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13055
13056 if (_kernel_accel)
13057 {
13058 device_param->kernel_accel_min = _kernel_accel;
13059 device_param->kernel_accel_max = _kernel_accel;
13060 }
13061
13062 if (_kernel_loops)
13063 {
13064 if (workload_profile == 1)
13065 {
13066 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13067 }
13068 else if (workload_profile == 2)
13069 {
13070 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13071 }
13072
13073 device_param->kernel_loops_min = _kernel_loops;
13074 device_param->kernel_loops_max = _kernel_loops;
13075 }
13076 }
13077
13078 // commandline parameters overwrite tuningdb entries
13079
13080 if (kernel_accel)
13081 {
13082 device_param->kernel_accel_min = kernel_accel;
13083 device_param->kernel_accel_max = kernel_accel;
13084 }
13085
13086 if (kernel_loops)
13087 {
13088 device_param->kernel_loops_min = kernel_loops;
13089 device_param->kernel_loops_max = kernel_loops;
13090 }
13091
13092 /**
13093 * activate device
13094 */
13095
13096 devices_active++;
13097 }
13098
13099 // next please
13100
13101 devices_cnt++;
13102 }
13103 }
13104
13105 if (keyspace == 0 && devices_active == 0)
13106 {
13107 log_error ("ERROR: No devices found/left");
13108
13109 return (-1);
13110 }
13111
13112 // 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)
13113
13114 if (devices_filter != (uint) -1)
13115 {
13116 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
13117
13118 if (devices_filter > devices_cnt_mask)
13119 {
13120 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
13121
13122 return (-1);
13123 }
13124 }
13125
13126 data.devices_cnt = devices_cnt;
13127
13128 data.devices_active = devices_active;
13129
13130 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13131 {
13132 log_info ("");
13133 }
13134
13135 /**
13136 * HM devices: init
13137 */
13138
13139 #ifdef HAVE_HWMON
13140 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13141 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13142 #endif
13143
13144 #ifdef HAVE_ADL
13145 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13146 #endif
13147
13148 if (gpu_temp_disable == 0)
13149 {
13150 #if defined(WIN) && defined(HAVE_NVAPI)
13151 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13152
13153 if (nvapi_init (nvapi) == 0)
13154 data.hm_nv = nvapi;
13155
13156 if (data.hm_nv)
13157 {
13158 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13159 {
13160 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13161
13162 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13163
13164 int tmp_out = 0;
13165
13166 for (int i = 0; i < tmp_in; i++)
13167 {
13168 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13169 }
13170
13171 for (int i = 0; i < tmp_out; i++)
13172 {
13173 NV_GPU_COOLER_SETTINGS pCoolerSettings;
13174
13175 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
13176
13177 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;
13178 }
13179 }
13180 }
13181 #endif // WIN && HAVE_NVAPI
13182
13183 #if defined(LINUX) && defined(HAVE_NVML)
13184 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13185
13186 if (nvml_init (nvml) == 0)
13187 data.hm_nv = nvml;
13188
13189 if (data.hm_nv)
13190 {
13191 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13192 {
13193 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13194
13195 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13196
13197 int tmp_out = 0;
13198
13199 for (int i = 0; i < tmp_in; i++)
13200 {
13201 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13202 }
13203
13204 for (int i = 0; i < tmp_out; i++)
13205 {
13206 unsigned int speed;
13207
13208 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;
13209 }
13210 }
13211 }
13212 #endif // LINUX && HAVE_NVML
13213
13214 data.hm_amd = NULL;
13215
13216 #ifdef HAVE_ADL
13217 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13218
13219 if (adl_init (adl) == 0)
13220 data.hm_amd = adl;
13221
13222 if (data.hm_amd)
13223 {
13224 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13225 {
13226 // total number of adapters
13227
13228 int hm_adapters_num;
13229
13230 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13231
13232 // adapter info
13233
13234 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13235
13236 if (lpAdapterInfo == NULL) return (-1);
13237
13238 // get a list (of ids of) valid/usable adapters
13239
13240 int num_adl_adapters = 0;
13241
13242 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13243
13244 if (num_adl_adapters > 0)
13245 {
13246 hc_thread_mutex_lock (mux_adl);
13247
13248 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13249
13250 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13251
13252 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13253 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13254
13255 hc_thread_mutex_unlock (mux_adl);
13256 }
13257
13258 myfree (valid_adl_device_list);
13259 myfree (lpAdapterInfo);
13260 }
13261 }
13262 #endif // HAVE_ADL
13263
13264 if (data.hm_amd == NULL && data.hm_nv == NULL)
13265 {
13266 gpu_temp_disable = 1;
13267 }
13268 }
13269
13270 /**
13271 * OpenCL devices: allocate buffer for device specific information
13272 */
13273
13274 #ifdef HAVE_HWMON
13275 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13276
13277 #ifdef HAVE_ADL
13278 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13279
13280 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13281 #endif // ADL
13282 #endif
13283
13284 /**
13285 * enable custom signal handler(s)
13286 */
13287
13288 if (benchmark == 0)
13289 {
13290 hc_signal (sigHandler_default);
13291 }
13292 else
13293 {
13294 hc_signal (sigHandler_benchmark);
13295 }
13296
13297 /**
13298 * User-defined GPU temp handling
13299 */
13300
13301 #ifdef HAVE_HWMON
13302 if (gpu_temp_disable == 1)
13303 {
13304 gpu_temp_abort = 0;
13305 gpu_temp_retain = 0;
13306 }
13307
13308 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13309 {
13310 if (gpu_temp_abort < gpu_temp_retain)
13311 {
13312 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13313
13314 return (-1);
13315 }
13316 }
13317
13318 data.gpu_temp_disable = gpu_temp_disable;
13319 data.gpu_temp_abort = gpu_temp_abort;
13320 data.gpu_temp_retain = gpu_temp_retain;
13321 #endif
13322
13323 /**
13324 * inform the user
13325 */
13326
13327 if (data.quiet == 0)
13328 {
13329 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13330
13331 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);
13332
13333 if (attack_mode == ATTACK_MODE_STRAIGHT)
13334 {
13335 log_info ("Rules: %u", kernel_rules_cnt);
13336 }
13337
13338 if (opti_type)
13339 {
13340 log_info ("Applicable Optimizers:");
13341
13342 for (uint i = 0; i < 32; i++)
13343 {
13344 const uint opti_bit = 1u << i;
13345
13346 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13347 }
13348 }
13349
13350 /**
13351 * Watchdog and Temperature balance
13352 */
13353
13354 #ifdef HAVE_HWMON
13355 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13356 {
13357 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13358 }
13359
13360 if (gpu_temp_abort == 0)
13361 {
13362 log_info ("Watchdog: Temperature abort trigger disabled");
13363 }
13364 else
13365 {
13366 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13367 }
13368
13369 if (gpu_temp_retain == 0)
13370 {
13371 log_info ("Watchdog: Temperature retain trigger disabled");
13372 }
13373 else
13374 {
13375 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13376 }
13377 #endif
13378 }
13379
13380 if (data.quiet == 0) log_info ("");
13381
13382 /**
13383 * HM devices: copy
13384 */
13385
13386 if (gpu_temp_disable == 0)
13387 {
13388 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13389 {
13390 hc_device_param_t *device_param = &data.devices_param[device_id];
13391
13392 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13393
13394 if (device_param->skipped) continue;
13395
13396 const uint platform_devices_id = device_param->platform_devices_id;
13397
13398 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13399 if (device_param->vendor_id == VENDOR_ID_NV)
13400 {
13401 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13402 }
13403 #endif
13404
13405 #ifdef HAVE_ADL
13406 if (device_param->vendor_id == VENDOR_ID_AMD)
13407 {
13408 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13409 }
13410 #endif
13411 }
13412 }
13413
13414 /*
13415 * Temporary fix:
13416 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13417 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13418 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13419 * Driver / ADL bug?
13420 */
13421
13422 #ifdef HAVE_ADL
13423 if (powertune_enable == 1)
13424 {
13425 hc_thread_mutex_lock (mux_adl);
13426
13427 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13428 {
13429 hc_device_param_t *device_param = &data.devices_param[device_id];
13430
13431 if (device_param->skipped) continue;
13432
13433 if (data.hm_device[device_id].od_version == 6)
13434 {
13435 // set powertune value only
13436
13437 int powertune_supported = 0;
13438
13439 int ADL_rc = 0;
13440
13441 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13442 {
13443 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13444
13445 return (-1);
13446 }
13447
13448 if (powertune_supported != 0)
13449 {
13450 // powertune set
13451 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13452
13453 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13454 {
13455 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13456
13457 return (-1);
13458 }
13459
13460 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13461 {
13462 log_error ("ERROR: Failed to set new ADL PowerControl values");
13463
13464 return (-1);
13465 }
13466 }
13467 }
13468 }
13469
13470 hc_thread_mutex_unlock (mux_adl);
13471 }
13472 #endif // HAVE_ADK
13473 #endif // HAVE_HWMON
13474
13475 #ifdef DEBUG
13476 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
13477 #endif
13478
13479 uint kernel_power_all = 0;
13480
13481 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13482 {
13483 /**
13484 * host buffer
13485 */
13486
13487 hc_device_param_t *device_param = &data.devices_param[device_id];
13488
13489 if (device_param->skipped) continue;
13490
13491 /**
13492 * device properties
13493 */
13494
13495 const char *device_name_chksum = device_param->device_name_chksum;
13496 const u32 device_processors = device_param->device_processors;
13497 const u32 device_processor_cores = device_param->device_processor_cores;
13498
13499 /**
13500 * create context for each device
13501 */
13502
13503 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
13504
13505 /**
13506 * create command-queue
13507 */
13508
13509 // not supported with NV
13510 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13511
13512 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
13513
13514 /**
13515 * create input buffers on device : calculate size of fixed memory buffers
13516 */
13517
13518 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13519 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13520
13521 device_param->size_root_css = size_root_css;
13522 device_param->size_markov_css = size_markov_css;
13523
13524 uint size_results = KERNEL_THREADS * sizeof (uint);
13525
13526 device_param->size_results = size_results;
13527
13528 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13529 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13530
13531 uint size_plains = digests_cnt * sizeof (plain_t);
13532 uint size_salts = salts_cnt * sizeof (salt_t);
13533 uint size_esalts = salts_cnt * esalt_size;
13534
13535 device_param->size_plains = size_plains;
13536 device_param->size_digests = size_digests;
13537 device_param->size_shown = size_shown;
13538 device_param->size_salts = size_salts;
13539
13540 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13541 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13542 uint size_tm = 32 * sizeof (bs_word_t);
13543
13544 // scryptV stuff
13545
13546 u64 size_scryptV = 1;
13547
13548 if ((hash_mode == 8900) || (hash_mode == 9300))
13549 {
13550 uint tmto_start = 0;
13551 uint tmto_stop = 10;
13552
13553 if (scrypt_tmto)
13554 {
13555 tmto_start = scrypt_tmto;
13556 }
13557 else
13558 {
13559 // in case the user did not specify the tmto manually
13560 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13561 // but set the lower end only in case the user has a device with too less memory
13562
13563 if (hash_mode == 8900)
13564 {
13565 if (device_param->vendor_id == VENDOR_ID_AMD)
13566 {
13567 tmto_start = 1;
13568 }
13569 else if (device_param->vendor_id == VENDOR_ID_NV)
13570 {
13571 tmto_start = 3;
13572 }
13573 }
13574 else if (hash_mode == 9300)
13575 {
13576 if (device_param->vendor_id == VENDOR_ID_AMD)
13577 {
13578 tmto_start = 3;
13579 }
13580 else if (device_param->vendor_id == VENDOR_ID_NV)
13581 {
13582 tmto_start = 5;
13583 }
13584 }
13585 }
13586
13587 if (quiet == 0) log_info ("");
13588
13589 uint shader_per_mp = 1;
13590
13591 if (device_param->vendor_id == VENDOR_ID_AMD)
13592 {
13593 shader_per_mp = 8;
13594 }
13595 else if (device_param->vendor_id == VENDOR_ID_NV)
13596 {
13597 shader_per_mp = 32;
13598 }
13599
13600 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13601 {
13602 // TODO: in theory the following calculation needs to be done per salt, not global
13603 // we assume all hashes have the same scrypt settings
13604
13605 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13606
13607 size_scryptV /= 1 << tmto;
13608
13609 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13610
13611 if (size_scryptV > device_param->device_maxmem_alloc)
13612 {
13613 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13614
13615 continue;
13616 }
13617
13618 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13619 {
13620 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13621 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13622 }
13623
13624 break;
13625 }
13626
13627 if (data.salts_buf[0].scrypt_phy == 0)
13628 {
13629 log_error ("ERROR: can't allocate enough device memory");
13630
13631 return -1;
13632 }
13633
13634 if (quiet == 0) log_info ("");
13635 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13636 }
13637
13638 /**
13639 * create input buffers on device : calculate size of dynamic size memory buffers
13640 */
13641
13642 uint kernel_threads = KERNEL_THREADS;
13643
13644 // some algorithms need a fixed kernel-threads count (mostly because of shared memory usage)
13645
13646 if (hash_mode == 3200) kernel_threads = 8;
13647 if (hash_mode == 9000) kernel_threads = 8;
13648
13649 /**
13650 * some algorithms need a fixed kernel-loops count
13651 */
13652
13653 if (hash_mode == 1500)
13654 {
13655 const u32 kernel_loops_fixed = 1024;
13656
13657 device_param->kernel_loops_min = kernel_loops_fixed;
13658 device_param->kernel_loops_max = kernel_loops_fixed;
13659 }
13660
13661 if (hash_mode == 3000)
13662 {
13663 const u32 kernel_loops_fixed = 1024;
13664
13665 device_param->kernel_loops_min = kernel_loops_fixed;
13666 device_param->kernel_loops_max = kernel_loops_fixed;
13667 }
13668
13669 if (hash_mode == 8900)
13670 {
13671 const u32 kernel_loops_fixed = 1;
13672
13673 device_param->kernel_loops_min = kernel_loops_fixed;
13674 device_param->kernel_loops_max = kernel_loops_fixed;
13675 }
13676
13677 if (hash_mode == 9300)
13678 {
13679 const u32 kernel_loops_fixed = 1;
13680
13681 device_param->kernel_loops_min = kernel_loops_fixed;
13682 device_param->kernel_loops_max = kernel_loops_fixed;
13683 }
13684
13685 if (hash_mode == 12500)
13686 {
13687 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
13688
13689 device_param->kernel_loops_min = kernel_loops_fixed;
13690 device_param->kernel_loops_max = kernel_loops_fixed;
13691 }
13692
13693 /**
13694 * some algorithms have a maximum kernel-loops count
13695 */
13696
13697 if (attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
13698 {
13699 if (data.salts_buf[0].salt_iter < device_param->kernel_loops_max)
13700 {
13701 device_param->kernel_loops_max = data.salts_buf[0].salt_iter;
13702 }
13703 }
13704
13705 /**
13706 * some algorithms need a special kernel-accel
13707 */
13708
13709 if (hash_mode == 8900)
13710 {
13711 device_param->kernel_accel_min = 1;
13712 device_param->kernel_accel_max = 64;
13713 }
13714
13715 if (hash_mode == 9300)
13716 {
13717 device_param->kernel_accel_min = 1;
13718 device_param->kernel_accel_max = 64;
13719 }
13720
13721 u32 kernel_accel_min = device_param->kernel_accel_min;
13722 u32 kernel_accel_max = device_param->kernel_accel_max;
13723
13724 // find out if we would request too much memory on memory blocks which are based on kernel_accel
13725
13726 uint size_pws = 4;
13727 uint size_tmps = 4;
13728 uint size_hooks = 4;
13729
13730 while (kernel_accel_max >= kernel_accel_min)
13731 {
13732 uint kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
13733
13734 // size_pws
13735
13736 size_pws = kernel_power_max * sizeof (pw_t);
13737
13738 // size_tmps
13739
13740 switch (hash_mode)
13741 {
13742 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
13743 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13744 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13745 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13746 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
13747 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
13748 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
13749 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
13750 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
13751 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
13752 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13753 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13754 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13755 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13756 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13757 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13758 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13759 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13760 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13761 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13762 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13763 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13764 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13765 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
13766 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
13767 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
13768 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
13769 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
13770 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13771 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13772 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
13773 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
13774 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13775 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
13776 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13777 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
13778 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
13779 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13780 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13781 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
13782 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
13783 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
13784 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13785 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
13786 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
13787 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
13788 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
13789 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13790 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
13791 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
13792 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
13793 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
13794 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13795 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
13796 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
13797 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
13798 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
13799 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
13800 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13801 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13802 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13803 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
13804 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
13805 };
13806
13807 // size_hooks
13808
13809 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13810 {
13811 // none yet
13812 }
13813
13814 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
13815 // if not, decrease amplifier and try again
13816
13817 int skip = 0;
13818
13819 if (size_pws > device_param->device_maxmem_alloc) skip = 1;
13820 if (size_tmps > device_param->device_maxmem_alloc) skip = 1;
13821 if (size_hooks > device_param->device_maxmem_alloc) skip = 1;
13822
13823 if (( bitmap_size
13824 + bitmap_size
13825 + bitmap_size
13826 + bitmap_size
13827 + bitmap_size
13828 + bitmap_size
13829 + bitmap_size
13830 + bitmap_size
13831 + size_bfs
13832 + size_combs
13833 + size_digests
13834 + size_esalts
13835 + size_hooks
13836 + size_markov_css
13837 + size_plains
13838 + size_pws
13839 + size_results
13840 + size_root_css
13841 + size_rules
13842 + size_rules_c
13843 + size_salts
13844 + size_scryptV
13845 + size_shown
13846 + size_tm
13847 + size_tmps) > device_param->device_global_mem) skip = 1;
13848
13849 if (skip == 1)
13850 {
13851 kernel_accel_max--;
13852
13853 continue;
13854 }
13855
13856 break;
13857 }
13858
13859 /*
13860 if (kernel_accel_max == 0)
13861 {
13862 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
13863
13864 return -1;
13865 }
13866 */
13867
13868 device_param->kernel_accel_min = kernel_accel_min;
13869 device_param->kernel_accel_max = kernel_accel_max;
13870
13871 /*
13872 if (kernel_accel_max < kernel_accel)
13873 {
13874 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
13875
13876 device_param->kernel_accel = kernel_accel_max;
13877 }
13878 */
13879
13880 device_param->size_bfs = size_bfs;
13881 device_param->size_combs = size_combs;
13882 device_param->size_rules = size_rules;
13883 device_param->size_rules_c = size_rules_c;
13884 device_param->size_pws = size_pws;
13885 device_param->size_tmps = size_tmps;
13886 device_param->size_hooks = size_hooks;
13887
13888 // do not confuse kernel_accel_max with kernel_accel here
13889
13890 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
13891
13892 device_param->kernel_threads = kernel_threads;
13893 device_param->kernel_power_user = kernel_power;
13894
13895 kernel_power_all += kernel_power;
13896
13897 /**
13898 * default building options
13899 */
13900
13901 char build_opts[1024] = { 0 };
13902
13903 // we don't have sm_* on vendors not NV but it doesn't matter
13904
13905 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);
13906
13907 /**
13908 * main kernel
13909 */
13910
13911 {
13912 /**
13913 * kernel source filename
13914 */
13915
13916 char source_file[256] = { 0 };
13917
13918 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13919
13920 struct stat sst;
13921
13922 if (stat (source_file, &sst) == -1)
13923 {
13924 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13925
13926 return -1;
13927 }
13928
13929 /**
13930 * kernel cached filename
13931 */
13932
13933 char cached_file[256] = { 0 };
13934
13935 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
13936
13937 int cached = 1;
13938
13939 struct stat cst;
13940
13941 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
13942 {
13943 cached = 0;
13944 }
13945
13946 /**
13947 * kernel compile or load
13948 */
13949
13950 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13951
13952 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13953
13954 if (force_jit_compilation == -1)
13955 {
13956 if (cached == 0)
13957 {
13958 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13959
13960 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13961
13962 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13963
13964 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
13965
13966 #ifdef DEBUG
13967 size_t build_log_size = 0;
13968
13969 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
13970
13971 if (build_log_size > 1)
13972 {
13973 char *build_log = (char *) malloc (build_log_size + 1);
13974
13975 memset (build_log, 0, build_log_size + 1);
13976
13977 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
13978
13979 puts (build_log);
13980
13981 free (build_log);
13982 }
13983 #endif
13984
13985 if (rc != 0)
13986 {
13987 device_param->skipped = true;
13988 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13989 continue;
13990 }
13991
13992 size_t binary_size;
13993
13994 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13995
13996 u8 *binary = (u8 *) mymalloc (binary_size);
13997
13998 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13999
14000 writeProgramBin (cached_file, binary, binary_size);
14001
14002 local_free (binary);
14003 }
14004 else
14005 {
14006 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14007
14008 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14009
14010 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14011
14012 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
14013 }
14014 }
14015 else
14016 {
14017 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
14018
14019 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14020
14021 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14022
14023 char build_opts_update[1024] = { 0 };
14024
14025 if (force_jit_compilation == 1500)
14026 {
14027 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
14028 }
14029 else if (force_jit_compilation == 8900)
14030 {
14031 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);
14032 }
14033 else
14034 {
14035 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
14036 }
14037
14038 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
14039
14040 #ifdef DEBUG
14041 size_t build_log_size = 0;
14042
14043 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14044
14045 if (build_log_size > 1)
14046 {
14047 char *build_log = (char *) malloc (build_log_size + 1);
14048
14049 memset (build_log, 0, build_log_size + 1);
14050
14051 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14052
14053 puts (build_log);
14054
14055 free (build_log);
14056 }
14057 #endif
14058
14059 if (rc != 0)
14060 {
14061 device_param->skipped = true;
14062
14063 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14064 }
14065 }
14066
14067 local_free (kernel_lengths);
14068 local_free (kernel_sources[0]);
14069 local_free (kernel_sources);
14070 }
14071
14072 /**
14073 * word generator kernel
14074 */
14075
14076 if (attack_mode != ATTACK_MODE_STRAIGHT)
14077 {
14078 /**
14079 * kernel mp source filename
14080 */
14081
14082 char source_file[256] = { 0 };
14083
14084 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
14085
14086 struct stat sst;
14087
14088 if (stat (source_file, &sst) == -1)
14089 {
14090 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14091
14092 return -1;
14093 }
14094
14095 /**
14096 * kernel mp cached filename
14097 */
14098
14099 char cached_file[256] = { 0 };
14100
14101 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
14102
14103 int cached = 1;
14104
14105 struct stat cst;
14106
14107 if (stat (cached_file, &cst) == -1)
14108 {
14109 cached = 0;
14110 }
14111
14112 /**
14113 * kernel compile or load
14114 */
14115
14116 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14117
14118 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14119
14120 if (cached == 0)
14121 {
14122 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14123
14124 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14125
14126 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14127
14128 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
14129
14130 if (rc != 0)
14131 {
14132 device_param->skipped = true;
14133 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14134 continue;
14135 }
14136
14137 size_t binary_size;
14138
14139 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14140
14141 u8 *binary = (u8 *) mymalloc (binary_size);
14142
14143 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14144
14145 writeProgramBin (cached_file, binary, binary_size);
14146
14147 local_free (binary);
14148 }
14149 else
14150 {
14151 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14152
14153 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14154
14155 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14156
14157 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
14158 }
14159
14160 local_free (kernel_lengths);
14161 local_free (kernel_sources[0]);
14162 local_free (kernel_sources);
14163 }
14164
14165 /**
14166 * amplifier kernel
14167 */
14168
14169 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14170 {
14171
14172 }
14173 else
14174 {
14175 /**
14176 * kernel amp source filename
14177 */
14178
14179 char source_file[256] = { 0 };
14180
14181 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
14182
14183 struct stat sst;
14184
14185 if (stat (source_file, &sst) == -1)
14186 {
14187 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14188
14189 return -1;
14190 }
14191
14192 /**
14193 * kernel amp cached filename
14194 */
14195
14196 char cached_file[256] = { 0 };
14197
14198 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
14199
14200 int cached = 1;
14201
14202 struct stat cst;
14203
14204 if (stat (cached_file, &cst) == -1)
14205 {
14206 cached = 0;
14207 }
14208
14209 /**
14210 * kernel compile or load
14211 */
14212
14213 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14214
14215 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14216
14217 if (cached == 0)
14218 {
14219 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14220
14221 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14222
14223 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14224
14225 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
14226
14227 if (rc != 0)
14228 {
14229 device_param->skipped = true;
14230 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14231 continue;
14232 }
14233
14234 size_t binary_size;
14235
14236 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14237
14238 u8 *binary = (u8 *) mymalloc (binary_size);
14239
14240 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14241
14242 writeProgramBin (cached_file, binary, binary_size);
14243
14244 local_free (binary);
14245 }
14246 else
14247 {
14248 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14249
14250 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14251
14252 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14253
14254 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
14255 }
14256
14257 local_free (kernel_lengths);
14258 local_free (kernel_sources[0]);
14259 local_free (kernel_sources);
14260 }
14261
14262 // some algorithm collide too fast, make that impossible
14263
14264 if (benchmark == 1)
14265 {
14266 ((uint *) digests_buf)[0] = -1;
14267 ((uint *) digests_buf)[1] = -1;
14268 ((uint *) digests_buf)[2] = -1;
14269 ((uint *) digests_buf)[3] = -1;
14270 }
14271
14272 /**
14273 * global buffers
14274 */
14275
14276 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14277 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14278 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
14279 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
14280 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14281 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14282 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14283 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14284 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14285 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14286 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14287 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14288 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
14289 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
14290 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
14291 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
14292 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
14293 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
14294
14295 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);
14296 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);
14297 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);
14298 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);
14299 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);
14300 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);
14301 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);
14302 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);
14303 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
14304 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
14305 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
14306
14307 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
14308 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
14309 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
14310 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
14311 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
14312 run_kernel_bzero (device_param, device_param->d_result, size_results);
14313
14314 /**
14315 * special buffers
14316 */
14317
14318 if (attack_kern == ATTACK_KERN_STRAIGHT)
14319 {
14320 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
14321 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
14322
14323 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
14324
14325 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
14326 }
14327 else if (attack_kern == ATTACK_KERN_COMBI)
14328 {
14329 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14330 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14331 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14332 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14333
14334 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
14335 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
14336 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14337 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14338 }
14339 else if (attack_kern == ATTACK_KERN_BF)
14340 {
14341 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14342 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14343 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
14344 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14345 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14346
14347 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
14348 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
14349 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
14350 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14351 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14352 }
14353
14354 if (size_esalts)
14355 {
14356 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
14357
14358 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
14359 }
14360
14361 /**
14362 * main host data
14363 */
14364
14365 uint *result = (uint *) mymalloc (size_results);
14366
14367 device_param->result = result;
14368
14369 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
14370
14371 device_param->pws_buf = pws_buf;
14372
14373 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
14374
14375 device_param->combs_buf = combs_buf;
14376
14377 void *hooks_buf = mymalloc (size_hooks);
14378
14379 device_param->hooks_buf = hooks_buf;
14380
14381 /**
14382 * kernel args
14383 */
14384
14385 device_param->kernel_params_buf32[21] = bitmap_mask;
14386 device_param->kernel_params_buf32[22] = bitmap_shift1;
14387 device_param->kernel_params_buf32[23] = bitmap_shift2;
14388 device_param->kernel_params_buf32[24] = 0; // salt_pos
14389 device_param->kernel_params_buf32[25] = 0; // loop_pos
14390 device_param->kernel_params_buf32[26] = 0; // loop_cnt
14391 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
14392 device_param->kernel_params_buf32[28] = 0; // digests_cnt
14393 device_param->kernel_params_buf32[29] = 0; // digests_offset
14394 device_param->kernel_params_buf32[30] = 0; // combs_mode
14395 device_param->kernel_params_buf32[31] = 0; // gid_max
14396
14397 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14398 ? &device_param->d_pws_buf
14399 : &device_param->d_pws_amp_buf;
14400 device_param->kernel_params[ 1] = &device_param->d_rules_c;
14401 device_param->kernel_params[ 2] = &device_param->d_combs_c;
14402 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
14403 device_param->kernel_params[ 4] = &device_param->d_tmps;
14404 device_param->kernel_params[ 5] = &device_param->d_hooks;
14405 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
14406 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
14407 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
14408 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
14409 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
14410 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
14411 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
14412 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
14413 device_param->kernel_params[14] = &device_param->d_plain_bufs;
14414 device_param->kernel_params[15] = &device_param->d_digests_buf;
14415 device_param->kernel_params[16] = &device_param->d_digests_shown;
14416 device_param->kernel_params[17] = &device_param->d_salt_bufs;
14417 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
14418 device_param->kernel_params[19] = &device_param->d_result;
14419 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
14420 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
14421 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
14422 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
14423 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
14424 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
14425 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
14426 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
14427 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
14428 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
14429 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
14430 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
14431
14432 device_param->kernel_params_mp_buf64[3] = 0;
14433 device_param->kernel_params_mp_buf32[4] = 0;
14434 device_param->kernel_params_mp_buf32[5] = 0;
14435 device_param->kernel_params_mp_buf32[6] = 0;
14436 device_param->kernel_params_mp_buf32[7] = 0;
14437 device_param->kernel_params_mp_buf32[8] = 0;
14438
14439 device_param->kernel_params_mp[0] = NULL;
14440 device_param->kernel_params_mp[1] = NULL;
14441 device_param->kernel_params_mp[2] = NULL;
14442 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
14443 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
14444 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
14445 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
14446 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
14447 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
14448
14449 device_param->kernel_params_mp_l_buf64[3] = 0;
14450 device_param->kernel_params_mp_l_buf32[4] = 0;
14451 device_param->kernel_params_mp_l_buf32[5] = 0;
14452 device_param->kernel_params_mp_l_buf32[6] = 0;
14453 device_param->kernel_params_mp_l_buf32[7] = 0;
14454 device_param->kernel_params_mp_l_buf32[8] = 0;
14455 device_param->kernel_params_mp_l_buf32[9] = 0;
14456
14457 device_param->kernel_params_mp_l[0] = NULL;
14458 device_param->kernel_params_mp_l[1] = NULL;
14459 device_param->kernel_params_mp_l[2] = NULL;
14460 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14461 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14462 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14463 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14464 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14465 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14466 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14467
14468 device_param->kernel_params_mp_r_buf64[3] = 0;
14469 device_param->kernel_params_mp_r_buf32[4] = 0;
14470 device_param->kernel_params_mp_r_buf32[5] = 0;
14471 device_param->kernel_params_mp_r_buf32[6] = 0;
14472 device_param->kernel_params_mp_r_buf32[7] = 0;
14473 device_param->kernel_params_mp_r_buf32[8] = 0;
14474
14475 device_param->kernel_params_mp_r[0] = NULL;
14476 device_param->kernel_params_mp_r[1] = NULL;
14477 device_param->kernel_params_mp_r[2] = NULL;
14478 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14479 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14480 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14481 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14482 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14483 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14484
14485 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14486 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14487
14488 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14489 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14490 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14491 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14492 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14493 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14494 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14495
14496 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14497 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14498
14499 /**
14500 * kernel name
14501 */
14502
14503 char kernel_name[64] = { 0 };
14504
14505 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14506 {
14507 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14508 {
14509 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14510
14511 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14512
14513 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14514
14515 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14516
14517 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14518
14519 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14520 }
14521 else
14522 {
14523 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14524
14525 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14526
14527 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14528
14529 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14530
14531 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14532
14533 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14534 }
14535
14536 if (data.attack_mode == ATTACK_MODE_BF)
14537 {
14538 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14539 {
14540 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14541
14542 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14543 }
14544 }
14545 }
14546 else
14547 {
14548 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14549
14550 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14551
14552 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14553
14554 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14555
14556 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14557
14558 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14559
14560 if (opts_type & OPTS_TYPE_HOOK12)
14561 {
14562 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14563
14564 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14565 }
14566
14567 if (opts_type & OPTS_TYPE_HOOK23)
14568 {
14569 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14570
14571 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14572 }
14573 }
14574
14575 for (uint i = 0; i <= 20; i++)
14576 {
14577 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14578 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14579 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14580
14581 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14582 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14583 }
14584
14585 for (uint i = 21; i <= 31; i++)
14586 {
14587 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14588 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14589 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14590
14591 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14592 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14593 }
14594
14595 if (attack_mode == ATTACK_MODE_BF)
14596 {
14597 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
14598 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
14599
14600 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14601 {
14602 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14603 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14604 }
14605 }
14606 else if (attack_mode == ATTACK_MODE_HYBRID1)
14607 {
14608 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14609 }
14610 else if (attack_mode == ATTACK_MODE_HYBRID2)
14611 {
14612 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14613 }
14614
14615 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14616 {
14617 // nothing to do
14618 }
14619 else
14620 {
14621 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
14622 }
14623
14624 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14625 {
14626 // nothing to do
14627 }
14628 else
14629 {
14630 for (uint i = 0; i < 5; i++)
14631 {
14632 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14633 }
14634
14635 for (uint i = 5; i < 7; i++)
14636 {
14637 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14638 }
14639 }
14640
14641 /**
14642 * Store initial fanspeed if gpu_temp_retain is enabled
14643 */
14644
14645 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
14646 int gpu_temp_retain_set = 0;
14647
14648 if (gpu_temp_disable == 0)
14649 {
14650 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14651 {
14652 hc_thread_mutex_lock (mux_adl);
14653
14654 if (data.hm_device[device_id].fan_supported == 1)
14655 {
14656 if (gpu_temp_retain_chgd == 0)
14657 {
14658 uint cur_temp = 0;
14659 uint default_temp = 0;
14660
14661 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);
14662
14663 if (ADL_rc == ADL_OK)
14664 {
14665 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14666
14667 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14668
14669 // special case with multi gpu setups: always use minimum retain
14670
14671 if (gpu_temp_retain_set == 0)
14672 {
14673 gpu_temp_retain = gpu_temp_retain_target;
14674 gpu_temp_retain_set = 1;
14675 }
14676 else
14677 {
14678 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14679 }
14680
14681 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14682 }
14683 }
14684
14685 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14686
14687 temp_retain_fanspeed_value[device_id] = fan_speed;
14688
14689 if (fan_speed == -1)
14690 {
14691 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14692
14693 temp_retain_fanspeed_value[device_id] = 0;
14694 }
14695 }
14696
14697 hc_thread_mutex_unlock (mux_adl);
14698 }
14699 }
14700
14701 /**
14702 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14703 */
14704
14705 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14706 {
14707 hc_thread_mutex_lock (mux_adl);
14708
14709 if (data.hm_device[device_id].od_version == 6)
14710 {
14711 int ADL_rc;
14712
14713 // check powertune capabilities first, if not available then skip device
14714
14715 int powertune_supported = 0;
14716
14717 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14718 {
14719 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14720
14721 return (-1);
14722 }
14723
14724 if (powertune_supported != 0)
14725 {
14726 // powercontrol settings
14727
14728 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14729
14730 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14731 {
14732 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14733 }
14734
14735 if (ADL_rc != ADL_OK)
14736 {
14737 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14738
14739 return (-1);
14740 }
14741
14742 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14743 {
14744 log_error ("ERROR: Failed to set new ADL PowerControl values");
14745
14746 return (-1);
14747 }
14748
14749 // clocks
14750
14751 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14752
14753 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14754
14755 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)
14756 {
14757 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14758
14759 return (-1);
14760 }
14761
14762 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14763
14764 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14765
14766 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14767 {
14768 log_error ("ERROR: Failed to get ADL device capabilities");
14769
14770 return (-1);
14771 }
14772
14773 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14774 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14775
14776 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14777 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14778
14779 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14780 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14781
14782 // warning if profile has too low max values
14783
14784 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14785 {
14786 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14787 }
14788
14789 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14790 {
14791 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14792 }
14793
14794 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14795
14796 performance_state->iNumberOfPerformanceLevels = 2;
14797
14798 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14799 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14800 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14801 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14802
14803 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)
14804 {
14805 log_info ("ERROR: Failed to set ADL performance state");
14806
14807 return (-1);
14808 }
14809
14810 local_free (performance_state);
14811 }
14812 }
14813
14814 hc_thread_mutex_unlock (mux_adl);
14815 }
14816 #endif // HAVE_HWMON && HAVE_ADL
14817 }
14818
14819 data.kernel_power_all = kernel_power_all;
14820
14821 if (data.quiet == 0) log_info ("");
14822
14823 /**
14824 * In benchmark-mode, inform user which algorithm is checked
14825 */
14826
14827 if (benchmark == 1)
14828 {
14829 quiet = 0;
14830
14831 data.quiet = quiet;
14832
14833 char *hash_type = strhashtype (data.hash_mode); // not a bug
14834
14835 log_info ("Hashtype: %s", hash_type);
14836 log_info ("");
14837 }
14838
14839 /**
14840 * keep track of the progress
14841 */
14842
14843 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14844 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14845 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14846
14847 /**
14848 * open filehandles
14849 */
14850
14851 #if _WIN
14852 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14853 {
14854 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14855
14856 return (-1);
14857 }
14858
14859 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14860 {
14861 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14862
14863 return (-1);
14864 }
14865
14866 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14867 {
14868 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14869
14870 return (-1);
14871 }
14872 #endif
14873
14874 /**
14875 * dictionary pad
14876 */
14877
14878 segment_size *= (1024 * 1024);
14879
14880 data.segment_size = segment_size;
14881
14882 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14883
14884 wl_data->buf = (char *) mymalloc (segment_size);
14885 wl_data->avail = segment_size;
14886 wl_data->incr = segment_size;
14887 wl_data->cnt = 0;
14888 wl_data->pos = 0;
14889
14890 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14891
14892 data.wordlist_mode = wordlist_mode;
14893
14894 cs_t *css_buf = NULL;
14895 uint css_cnt = 0;
14896 uint dictcnt = 0;
14897 uint maskcnt = 1;
14898 char **masks = NULL;
14899 char **dictfiles = NULL;
14900
14901 uint mask_from_file = 0;
14902
14903 if (attack_mode == ATTACK_MODE_STRAIGHT)
14904 {
14905 if (wordlist_mode == WL_MODE_FILE)
14906 {
14907 int wls_left = myargc - (optind + 1);
14908
14909 for (int i = 0; i < wls_left; i++)
14910 {
14911 char *l0_filename = myargv[optind + 1 + i];
14912
14913 struct stat l0_stat;
14914
14915 if (stat (l0_filename, &l0_stat) == -1)
14916 {
14917 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14918
14919 return (-1);
14920 }
14921
14922 uint is_dir = S_ISDIR (l0_stat.st_mode);
14923
14924 if (is_dir == 0)
14925 {
14926 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14927
14928 dictcnt++;
14929
14930 dictfiles[dictcnt - 1] = l0_filename;
14931 }
14932 else
14933 {
14934 // do not allow --keyspace w/ a directory
14935
14936 if (keyspace == 1)
14937 {
14938 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14939
14940 return (-1);
14941 }
14942
14943 char **dictionary_files = NULL;
14944
14945 dictionary_files = scan_directory (l0_filename);
14946
14947 if (dictionary_files != NULL)
14948 {
14949 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14950
14951 for (int d = 0; dictionary_files[d] != NULL; d++)
14952 {
14953 char *l1_filename = dictionary_files[d];
14954
14955 struct stat l1_stat;
14956
14957 if (stat (l1_filename, &l1_stat) == -1)
14958 {
14959 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14960
14961 return (-1);
14962 }
14963
14964 if (S_ISREG (l1_stat.st_mode))
14965 {
14966 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14967
14968 dictcnt++;
14969
14970 dictfiles[dictcnt - 1] = strdup (l1_filename);
14971 }
14972 }
14973 }
14974
14975 local_free (dictionary_files);
14976 }
14977 }
14978
14979 if (dictcnt < 1)
14980 {
14981 log_error ("ERROR: No usable dictionary file found.");
14982
14983 return (-1);
14984 }
14985 }
14986 else if (wordlist_mode == WL_MODE_STDIN)
14987 {
14988 dictcnt = 1;
14989 }
14990 }
14991 else if (attack_mode == ATTACK_MODE_COMBI)
14992 {
14993 // display
14994
14995 char *dictfile1 = myargv[optind + 1 + 0];
14996 char *dictfile2 = myargv[optind + 1 + 1];
14997
14998 // find the bigger dictionary and use as base
14999
15000 FILE *fp1 = NULL;
15001 FILE *fp2 = NULL;
15002
15003 struct stat tmp_stat;
15004
15005 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
15006 {
15007 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15008
15009 return (-1);
15010 }
15011
15012 if (stat (dictfile1, &tmp_stat) == -1)
15013 {
15014 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15015
15016 fclose (fp1);
15017
15018 return (-1);
15019 }
15020
15021 if (S_ISDIR (tmp_stat.st_mode))
15022 {
15023 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
15024
15025 fclose (fp1);
15026
15027 return (-1);
15028 }
15029
15030 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
15031 {
15032 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15033
15034 fclose (fp1);
15035
15036 return (-1);
15037 }
15038
15039 if (stat (dictfile2, &tmp_stat) == -1)
15040 {
15041 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15042
15043 fclose (fp1);
15044 fclose (fp2);
15045
15046 return (-1);
15047 }
15048
15049 if (S_ISDIR (tmp_stat.st_mode))
15050 {
15051 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
15052
15053 fclose (fp1);
15054 fclose (fp2);
15055
15056 return (-1);
15057 }
15058
15059 data.combs_cnt = 1;
15060
15061 data.quiet = 1;
15062
15063 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
15064
15065 data.quiet = quiet;
15066
15067 if (words1_cnt == 0)
15068 {
15069 log_error ("ERROR: %s: empty file", dictfile1);
15070
15071 fclose (fp1);
15072 fclose (fp2);
15073
15074 return (-1);
15075 }
15076
15077 data.combs_cnt = 1;
15078
15079 data.quiet = 1;
15080
15081 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
15082
15083 data.quiet = quiet;
15084
15085 if (words2_cnt == 0)
15086 {
15087 log_error ("ERROR: %s: empty file", dictfile2);
15088
15089 fclose (fp1);
15090 fclose (fp2);
15091
15092 return (-1);
15093 }
15094
15095 fclose (fp1);
15096 fclose (fp2);
15097
15098 data.dictfile = dictfile1;
15099 data.dictfile2 = dictfile2;
15100
15101 if (words1_cnt >= words2_cnt)
15102 {
15103 data.combs_cnt = words2_cnt;
15104 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15105
15106 dictfiles = &data.dictfile;
15107
15108 dictcnt = 1;
15109 }
15110 else
15111 {
15112 data.combs_cnt = words1_cnt;
15113 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15114
15115 dictfiles = &data.dictfile2;
15116
15117 dictcnt = 1;
15118
15119 // we also have to switch wordlist related rules!
15120
15121 char *tmpc = data.rule_buf_l;
15122
15123 data.rule_buf_l = data.rule_buf_r;
15124 data.rule_buf_r = tmpc;
15125
15126 int tmpi = data.rule_len_l;
15127
15128 data.rule_len_l = data.rule_len_r;
15129 data.rule_len_r = tmpi;
15130 }
15131 }
15132 else if (attack_mode == ATTACK_MODE_BF)
15133 {
15134 char *mask = NULL;
15135
15136 maskcnt = 0;
15137
15138 if (benchmark == 0)
15139 {
15140 mask = myargv[optind + 1];
15141
15142 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
15143
15144 if ((optind + 2) <= myargc)
15145 {
15146 struct stat file_stat;
15147
15148 if (stat (mask, &file_stat) == -1)
15149 {
15150 maskcnt = 1;
15151
15152 masks[maskcnt - 1] = mystrdup (mask);
15153 }
15154 else
15155 {
15156 int wls_left = myargc - (optind + 1);
15157
15158 uint masks_avail = INCR_MASKS;
15159
15160 for (int i = 0; i < wls_left; i++)
15161 {
15162 if (i != 0)
15163 {
15164 mask = myargv[optind + 1 + i];
15165
15166 if (stat (mask, &file_stat) == -1)
15167 {
15168 log_error ("ERROR: %s: %s", mask, strerror (errno));
15169
15170 return (-1);
15171 }
15172 }
15173
15174 uint is_file = S_ISREG (file_stat.st_mode);
15175
15176 if (is_file == 1)
15177 {
15178 FILE *mask_fp;
15179
15180 if ((mask_fp = fopen (mask, "r")) == NULL)
15181 {
15182 log_error ("ERROR: %s: %s", mask, strerror (errno));
15183
15184 return (-1);
15185 }
15186
15187 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15188
15189 while (!feof (mask_fp))
15190 {
15191 memset (line_buf, 0, HCBUFSIZ);
15192
15193 int line_len = fgetl (mask_fp, line_buf);
15194
15195 if (line_len == 0) continue;
15196
15197 if (line_buf[0] == '#') continue;
15198
15199 if (masks_avail == maskcnt)
15200 {
15201 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15202
15203 masks_avail += INCR_MASKS;
15204 }
15205
15206 masks[maskcnt] = mystrdup (line_buf);
15207
15208 maskcnt++;
15209 }
15210
15211 myfree (line_buf);
15212
15213 fclose (mask_fp);
15214 }
15215 else
15216 {
15217 log_error ("ERROR: %s: unsupported file-type", mask);
15218
15219 return (-1);
15220 }
15221 }
15222
15223 mask_from_file = 1;
15224 }
15225 }
15226 else
15227 {
15228 custom_charset_1 = (char *) "?l?d?u";
15229 custom_charset_2 = (char *) "?l?d";
15230 custom_charset_3 = (char *) "?l?d*!$@_";
15231
15232 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15233 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15234 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15235
15236 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
15237
15238 wordlist_mode = WL_MODE_MASK;
15239
15240 data.wordlist_mode = wordlist_mode;
15241
15242 increment = 1;
15243
15244 maskcnt = 1;
15245 }
15246 }
15247 else
15248 {
15249 /**
15250 * generate full masks and charsets
15251 */
15252
15253 masks = (char **) mymalloc (sizeof (char *));
15254
15255 switch (hash_mode)
15256 {
15257 case 1731: pw_min = 5;
15258 pw_max = 5;
15259 mask = mystrdup ("?b?b?b?b?b");
15260 break;
15261 case 12500: pw_min = 5;
15262 pw_max = 5;
15263 mask = mystrdup ("?b?b?b?b?b");
15264 break;
15265 default: pw_min = 7;
15266 pw_max = 7;
15267 mask = mystrdup ("?b?b?b?b?b?b?b");
15268 break;
15269 }
15270
15271 maskcnt = 1;
15272
15273 masks[maskcnt - 1] = mystrdup (mask);
15274
15275 wordlist_mode = WL_MODE_MASK;
15276
15277 data.wordlist_mode = wordlist_mode;
15278
15279 increment = 1;
15280 }
15281
15282 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
15283
15284 if (increment)
15285 {
15286 if (increment_min > pw_min) pw_min = increment_min;
15287
15288 if (increment_max < pw_max) pw_max = increment_max;
15289 }
15290 }
15291 else if (attack_mode == ATTACK_MODE_HYBRID1)
15292 {
15293 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15294
15295 // display
15296
15297 char *mask = myargv[myargc - 1];
15298
15299 maskcnt = 0;
15300
15301 masks = (char **) mymalloc (1 * sizeof (char *));
15302
15303 // mod
15304
15305 struct stat file_stat;
15306
15307 if (stat (mask, &file_stat) == -1)
15308 {
15309 maskcnt = 1;
15310
15311 masks[maskcnt - 1] = mystrdup (mask);
15312 }
15313 else
15314 {
15315 uint is_file = S_ISREG (file_stat.st_mode);
15316
15317 if (is_file == 1)
15318 {
15319 FILE *mask_fp;
15320
15321 if ((mask_fp = fopen (mask, "r")) == NULL)
15322 {
15323 log_error ("ERROR: %s: %s", mask, strerror (errno));
15324
15325 return (-1);
15326 }
15327
15328 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15329
15330 uint masks_avail = 1;
15331
15332 while (!feof (mask_fp))
15333 {
15334 memset (line_buf, 0, HCBUFSIZ);
15335
15336 int line_len = fgetl (mask_fp, line_buf);
15337
15338 if (line_len == 0) continue;
15339
15340 if (line_buf[0] == '#') continue;
15341
15342 if (masks_avail == maskcnt)
15343 {
15344 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15345
15346 masks_avail += INCR_MASKS;
15347 }
15348
15349 masks[maskcnt] = mystrdup (line_buf);
15350
15351 maskcnt++;
15352 }
15353
15354 myfree (line_buf);
15355
15356 fclose (mask_fp);
15357
15358 mask_from_file = 1;
15359 }
15360 else
15361 {
15362 maskcnt = 1;
15363
15364 masks[maskcnt - 1] = mystrdup (mask);
15365 }
15366 }
15367
15368 // base
15369
15370 int wls_left = myargc - (optind + 2);
15371
15372 for (int i = 0; i < wls_left; i++)
15373 {
15374 char *filename = myargv[optind + 1 + i];
15375
15376 struct stat file_stat;
15377
15378 if (stat (filename, &file_stat) == -1)
15379 {
15380 log_error ("ERROR: %s: %s", filename, strerror (errno));
15381
15382 return (-1);
15383 }
15384
15385 uint is_dir = S_ISDIR (file_stat.st_mode);
15386
15387 if (is_dir == 0)
15388 {
15389 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15390
15391 dictcnt++;
15392
15393 dictfiles[dictcnt - 1] = filename;
15394 }
15395 else
15396 {
15397 // do not allow --keyspace w/ a directory
15398
15399 if (keyspace == 1)
15400 {
15401 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15402
15403 return (-1);
15404 }
15405
15406 char **dictionary_files = NULL;
15407
15408 dictionary_files = scan_directory (filename);
15409
15410 if (dictionary_files != NULL)
15411 {
15412 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15413
15414 for (int d = 0; dictionary_files[d] != NULL; d++)
15415 {
15416 char *l1_filename = dictionary_files[d];
15417
15418 struct stat l1_stat;
15419
15420 if (stat (l1_filename, &l1_stat) == -1)
15421 {
15422 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15423
15424 return (-1);
15425 }
15426
15427 if (S_ISREG (l1_stat.st_mode))
15428 {
15429 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15430
15431 dictcnt++;
15432
15433 dictfiles[dictcnt - 1] = strdup (l1_filename);
15434 }
15435 }
15436 }
15437
15438 local_free (dictionary_files);
15439 }
15440 }
15441
15442 if (dictcnt < 1)
15443 {
15444 log_error ("ERROR: No usable dictionary file found.");
15445
15446 return (-1);
15447 }
15448
15449 if (increment)
15450 {
15451 maskcnt = 0;
15452
15453 uint mask_min = increment_min; // we can't reject smaller masks here
15454 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15455
15456 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15457 {
15458 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15459
15460 if (cur_mask == NULL) break;
15461
15462 masks[maskcnt] = cur_mask;
15463
15464 maskcnt++;
15465
15466 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15467 }
15468 }
15469 }
15470 else if (attack_mode == ATTACK_MODE_HYBRID2)
15471 {
15472 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15473
15474 // display
15475
15476 char *mask = myargv[optind + 1 + 0];
15477
15478 maskcnt = 0;
15479
15480 masks = (char **) mymalloc (1 * sizeof (char *));
15481
15482 // mod
15483
15484 struct stat file_stat;
15485
15486 if (stat (mask, &file_stat) == -1)
15487 {
15488 maskcnt = 1;
15489
15490 masks[maskcnt - 1] = mystrdup (mask);
15491 }
15492 else
15493 {
15494 uint is_file = S_ISREG (file_stat.st_mode);
15495
15496 if (is_file == 1)
15497 {
15498 FILE *mask_fp;
15499
15500 if ((mask_fp = fopen (mask, "r")) == NULL)
15501 {
15502 log_error ("ERROR: %s: %s", mask, strerror (errno));
15503
15504 return (-1);
15505 }
15506
15507 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15508
15509 uint masks_avail = 1;
15510
15511 while (!feof (mask_fp))
15512 {
15513 memset (line_buf, 0, HCBUFSIZ);
15514
15515 int line_len = fgetl (mask_fp, line_buf);
15516
15517 if (line_len == 0) continue;
15518
15519 if (line_buf[0] == '#') continue;
15520
15521 if (masks_avail == maskcnt)
15522 {
15523 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15524
15525 masks_avail += INCR_MASKS;
15526 }
15527
15528 masks[maskcnt] = mystrdup (line_buf);
15529
15530 maskcnt++;
15531 }
15532
15533 myfree (line_buf);
15534
15535 fclose (mask_fp);
15536
15537 mask_from_file = 1;
15538 }
15539 else
15540 {
15541 maskcnt = 1;
15542
15543 masks[maskcnt - 1] = mystrdup (mask);
15544 }
15545 }
15546
15547 // base
15548
15549 int wls_left = myargc - (optind + 2);
15550
15551 for (int i = 0; i < wls_left; i++)
15552 {
15553 char *filename = myargv[optind + 2 + i];
15554
15555 struct stat file_stat;
15556
15557 if (stat (filename, &file_stat) == -1)
15558 {
15559 log_error ("ERROR: %s: %s", filename, strerror (errno));
15560
15561 return (-1);
15562 }
15563
15564 uint is_dir = S_ISDIR (file_stat.st_mode);
15565
15566 if (is_dir == 0)
15567 {
15568 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15569
15570 dictcnt++;
15571
15572 dictfiles[dictcnt - 1] = filename;
15573 }
15574 else
15575 {
15576 // do not allow --keyspace w/ a directory
15577
15578 if (keyspace == 1)
15579 {
15580 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15581
15582 return (-1);
15583 }
15584
15585 char **dictionary_files = NULL;
15586
15587 dictionary_files = scan_directory (filename);
15588
15589 if (dictionary_files != NULL)
15590 {
15591 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15592
15593 for (int d = 0; dictionary_files[d] != NULL; d++)
15594 {
15595 char *l1_filename = dictionary_files[d];
15596
15597 struct stat l1_stat;
15598
15599 if (stat (l1_filename, &l1_stat) == -1)
15600 {
15601 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15602
15603 return (-1);
15604 }
15605
15606 if (S_ISREG (l1_stat.st_mode))
15607 {
15608 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15609
15610 dictcnt++;
15611
15612 dictfiles[dictcnt - 1] = strdup (l1_filename);
15613 }
15614 }
15615 }
15616
15617 local_free (dictionary_files);
15618 }
15619 }
15620
15621 if (dictcnt < 1)
15622 {
15623 log_error ("ERROR: No usable dictionary file found.");
15624
15625 return (-1);
15626 }
15627
15628 if (increment)
15629 {
15630 maskcnt = 0;
15631
15632 uint mask_min = increment_min; // we can't reject smaller masks here
15633 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15634
15635 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15636 {
15637 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15638
15639 if (cur_mask == NULL) break;
15640
15641 masks[maskcnt] = cur_mask;
15642
15643 maskcnt++;
15644
15645 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15646 }
15647 }
15648 }
15649
15650 data.pw_min = pw_min;
15651 data.pw_max = pw_max;
15652
15653 /**
15654 * weak hash check
15655 */
15656
15657 if (weak_hash_threshold >= salts_cnt)
15658 {
15659 hc_device_param_t *device_param = NULL;
15660
15661 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15662 {
15663 device_param = &data.devices_param[device_id];
15664
15665 if (device_param->skipped) continue;
15666
15667 break;
15668 }
15669
15670 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15671
15672 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15673 {
15674 weak_hash_check (device_param, salt_pos);
15675 }
15676 }
15677
15678 // Display hack, guarantee that there is at least one \r before real start
15679
15680 if (data.quiet == 0) log_info_nn ("");
15681
15682 /**
15683 * status and monitor threads
15684 */
15685
15686 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15687
15688 hc_thread_t i_thread = 0;
15689
15690 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15691 {
15692 hc_thread_create (i_thread, thread_keypress, &benchmark);
15693 }
15694
15695 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15696
15697 uint ni_threads_cnt = 0;
15698
15699 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15700
15701 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15702
15703 ni_threads_cnt++;
15704
15705 /**
15706 * Outfile remove
15707 */
15708
15709 if (keyspace == 0)
15710 {
15711 if (outfile_check_timer != 0)
15712 {
15713 if (data.outfile_check_directory != NULL)
15714 {
15715 if ((hash_mode != 5200) &&
15716 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15717 (hash_mode != 9000))
15718 {
15719 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15720
15721 ni_threads_cnt++;
15722 }
15723 else
15724 {
15725 outfile_check_timer = 0;
15726 }
15727 }
15728 else
15729 {
15730 outfile_check_timer = 0;
15731 }
15732 }
15733 }
15734
15735 /**
15736 * Inform the user if we got some hashes remove because of the pot file remove feature
15737 */
15738
15739 if (data.quiet == 0)
15740 {
15741 if (potfile_remove_cracks > 0)
15742 {
15743 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15744 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15745 }
15746 }
15747
15748 data.outfile_check_timer = outfile_check_timer;
15749
15750 /**
15751 * main loop
15752 */
15753
15754 char **induction_dictionaries = NULL;
15755
15756 int induction_dictionaries_cnt = 0;
15757
15758 hcstat_table_t *root_table_buf = NULL;
15759 hcstat_table_t *markov_table_buf = NULL;
15760
15761 uint initial_restore_done = 0;
15762
15763 data.maskcnt = maskcnt;
15764
15765 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15766 {
15767 if (data.devices_status == STATUS_CRACKED) break;
15768
15769 data.devices_status = STATUS_INIT;
15770
15771 if (maskpos > rd->maskpos)
15772 {
15773 rd->dictpos = 0;
15774 }
15775
15776 rd->maskpos = maskpos;
15777 data.maskpos = maskpos;
15778
15779 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15780 {
15781 char *mask = masks[maskpos];
15782
15783 if (mask_from_file == 1)
15784 {
15785 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15786
15787 char *str_ptr;
15788 uint str_pos;
15789
15790 uint mask_offset = 0;
15791
15792 uint separator_cnt;
15793
15794 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15795 {
15796 str_ptr = strstr (mask + mask_offset, ",");
15797
15798 if (str_ptr == NULL) break;
15799
15800 str_pos = str_ptr - mask;
15801
15802 // escaped separator, i.e. "\,"
15803
15804 if (str_pos > 0)
15805 {
15806 if (mask[str_pos - 1] == '\\')
15807 {
15808 separator_cnt --;
15809
15810 mask_offset = str_pos + 1;
15811
15812 continue;
15813 }
15814 }
15815
15816 // reset the offset
15817
15818 mask_offset = 0;
15819
15820 mask[str_pos] = '\0';
15821
15822 switch (separator_cnt)
15823 {
15824 case 0:
15825 mp_reset_usr (mp_usr, 0);
15826
15827 custom_charset_1 = mask;
15828 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15829 break;
15830
15831 case 1:
15832 mp_reset_usr (mp_usr, 1);
15833
15834 custom_charset_2 = mask;
15835 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15836 break;
15837
15838 case 2:
15839 mp_reset_usr (mp_usr, 2);
15840
15841 custom_charset_3 = mask;
15842 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15843 break;
15844
15845 case 3:
15846 mp_reset_usr (mp_usr, 3);
15847
15848 custom_charset_4 = mask;
15849 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15850 break;
15851 }
15852
15853 mask = mask + str_pos + 1;
15854 }
15855 }
15856
15857 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15858 {
15859 if (maskpos > 0)
15860 {
15861 local_free (css_buf);
15862 local_free (data.root_css_buf);
15863 local_free (data.markov_css_buf);
15864
15865 local_free (masks[maskpos - 1]);
15866 }
15867
15868 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15869
15870 data.mask = mask;
15871 data.css_cnt = css_cnt;
15872 data.css_buf = css_buf;
15873
15874 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15875
15876 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15877
15878 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15879 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15880
15881 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15882
15883 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15884
15885 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15886 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15887
15888 data.root_css_buf = root_css_buf;
15889 data.markov_css_buf = markov_css_buf;
15890
15891 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15892
15893 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15894
15895 local_free (root_table_buf);
15896 local_free (markov_table_buf);
15897
15898 // args
15899
15900 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15901 {
15902 hc_device_param_t *device_param = &data.devices_param[device_id];
15903
15904 if (device_param->skipped) continue;
15905
15906 device_param->kernel_params_mp[0] = &device_param->d_combs;
15907 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15908 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15909
15910 device_param->kernel_params_mp_buf64[3] = 0;
15911 device_param->kernel_params_mp_buf32[4] = css_cnt;
15912 device_param->kernel_params_mp_buf32[5] = 0;
15913 device_param->kernel_params_mp_buf32[6] = 0;
15914 device_param->kernel_params_mp_buf32[7] = 0;
15915
15916 if (attack_mode == ATTACK_MODE_HYBRID1)
15917 {
15918 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15919 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15920 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15921 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15922 }
15923 else if (attack_mode == ATTACK_MODE_HYBRID2)
15924 {
15925 device_param->kernel_params_mp_buf32[5] = 0;
15926 device_param->kernel_params_mp_buf32[6] = 0;
15927 device_param->kernel_params_mp_buf32[7] = 0;
15928 }
15929
15930 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]);
15931 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]);
15932 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]);
15933
15934 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);
15935 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);
15936 }
15937 }
15938 else if (attack_mode == ATTACK_MODE_BF)
15939 {
15940 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15941
15942 if (increment)
15943 {
15944 for (uint i = 0; i < dictcnt; i++)
15945 {
15946 local_free (dictfiles[i]);
15947 }
15948
15949 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15950 {
15951 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15952
15953 if (l1_filename == NULL) break;
15954
15955 dictcnt++;
15956
15957 dictfiles[dictcnt - 1] = l1_filename;
15958 }
15959 }
15960 else
15961 {
15962 dictcnt++;
15963
15964 dictfiles[dictcnt - 1] = mask;
15965 }
15966
15967 if (dictcnt == 0)
15968 {
15969 log_error ("ERROR: Mask is too small");
15970
15971 return (-1);
15972 }
15973 }
15974 }
15975
15976 free (induction_dictionaries);
15977
15978 // induction_dictionaries_cnt = 0; // implied
15979
15980 if (attack_mode != ATTACK_MODE_BF)
15981 {
15982 if (keyspace == 0)
15983 {
15984 induction_dictionaries = scan_directory (induction_directory);
15985
15986 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15987 }
15988 }
15989
15990 if (induction_dictionaries_cnt)
15991 {
15992 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15993 }
15994
15995 /**
15996 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15997 */
15998 if (keyspace == 1)
15999 {
16000 if ((maskcnt > 1) || (dictcnt > 1))
16001 {
16002 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
16003
16004 return (-1);
16005 }
16006 }
16007
16008 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
16009 {
16010 char *subid = logfile_generate_subid ();
16011
16012 data.subid = subid;
16013
16014 logfile_sub_msg ("START");
16015
16016 data.devices_status = STATUS_INIT;
16017
16018 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
16019 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
16020 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
16021
16022 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
16023
16024 data.cpt_pos = 0;
16025
16026 data.cpt_start = time (NULL);
16027
16028 data.cpt_total = 0;
16029
16030 if (data.restore == 0)
16031 {
16032 rd->words_cur = skip;
16033
16034 skip = 0;
16035
16036 data.skip = 0;
16037 }
16038
16039 data.ms_paused = 0;
16040
16041 data.words_cur = rd->words_cur;
16042
16043 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16044 {
16045 hc_device_param_t *device_param = &data.devices_param[device_id];
16046
16047 if (device_param->skipped) continue;
16048
16049 device_param->speed_pos = 0;
16050
16051 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
16052 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
16053
16054 device_param->exec_pos = 0;
16055
16056 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
16057
16058 device_param->kernel_power = device_param->kernel_power_user;
16059
16060 device_param->outerloop_pos = 0;
16061 device_param->outerloop_left = 0;
16062 device_param->innerloop_pos = 0;
16063 device_param->innerloop_left = 0;
16064
16065 // some more resets:
16066
16067 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
16068
16069 device_param->pws_cnt = 0;
16070
16071 device_param->words_off = 0;
16072 device_param->words_done = 0;
16073 }
16074
16075 data.kernel_power_div = 0;
16076
16077 // figure out some workload
16078
16079 if (attack_mode == ATTACK_MODE_STRAIGHT)
16080 {
16081 if (data.wordlist_mode == WL_MODE_FILE)
16082 {
16083 char *dictfile = NULL;
16084
16085 if (induction_dictionaries_cnt)
16086 {
16087 dictfile = induction_dictionaries[0];
16088 }
16089 else
16090 {
16091 dictfile = dictfiles[dictpos];
16092 }
16093
16094 data.dictfile = dictfile;
16095
16096 logfile_sub_string (dictfile);
16097
16098 for (uint i = 0; i < rp_files_cnt; i++)
16099 {
16100 logfile_sub_var_string ("rulefile", rp_files[i]);
16101 }
16102
16103 FILE *fd2 = fopen (dictfile, "rb");
16104
16105 if (fd2 == NULL)
16106 {
16107 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16108
16109 return (-1);
16110 }
16111
16112 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16113
16114 fclose (fd2);
16115
16116 if (data.words_cnt == 0)
16117 {
16118 if (data.devices_status == STATUS_CRACKED) break;
16119 if (data.devices_status == STATUS_ABORTED) break;
16120
16121 dictpos++;
16122
16123 continue;
16124 }
16125 }
16126 }
16127 else if (attack_mode == ATTACK_MODE_COMBI)
16128 {
16129 char *dictfile = data.dictfile;
16130 char *dictfile2 = data.dictfile2;
16131
16132 logfile_sub_string (dictfile);
16133 logfile_sub_string (dictfile2);
16134
16135 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
16136 {
16137 FILE *fd2 = fopen (dictfile, "rb");
16138
16139 if (fd2 == NULL)
16140 {
16141 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16142
16143 return (-1);
16144 }
16145
16146 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16147
16148 fclose (fd2);
16149 }
16150 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
16151 {
16152 FILE *fd2 = fopen (dictfile2, "rb");
16153
16154 if (fd2 == NULL)
16155 {
16156 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16157
16158 return (-1);
16159 }
16160
16161 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
16162
16163 fclose (fd2);
16164 }
16165
16166 if (data.words_cnt == 0)
16167 {
16168 if (data.devices_status == STATUS_CRACKED) break;
16169 if (data.devices_status == STATUS_ABORTED) break;
16170
16171 dictpos++;
16172
16173 continue;
16174 }
16175 }
16176 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16177 {
16178 char *dictfile = NULL;
16179
16180 if (induction_dictionaries_cnt)
16181 {
16182 dictfile = induction_dictionaries[0];
16183 }
16184 else
16185 {
16186 dictfile = dictfiles[dictpos];
16187 }
16188
16189 data.dictfile = dictfile;
16190
16191 char *mask = data.mask;
16192
16193 logfile_sub_string (dictfile);
16194 logfile_sub_string (mask);
16195
16196 FILE *fd2 = fopen (dictfile, "rb");
16197
16198 if (fd2 == NULL)
16199 {
16200 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16201
16202 return (-1);
16203 }
16204
16205 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16206
16207 fclose (fd2);
16208
16209 if (data.words_cnt == 0)
16210 {
16211 if (data.devices_status == STATUS_CRACKED) break;
16212 if (data.devices_status == STATUS_ABORTED) break;
16213
16214 dictpos++;
16215
16216 continue;
16217 }
16218 }
16219 else if (attack_mode == ATTACK_MODE_BF)
16220 {
16221 local_free (css_buf);
16222 local_free (data.root_css_buf);
16223 local_free (data.markov_css_buf);
16224
16225 char *mask = dictfiles[dictpos];
16226
16227 logfile_sub_string (mask);
16228
16229 // base
16230
16231 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16232
16233 if (opts_type & OPTS_TYPE_PT_UNICODE)
16234 {
16235 uint css_cnt_unicode = css_cnt * 2;
16236
16237 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
16238
16239 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
16240 {
16241 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
16242
16243 css_buf_unicode[j + 1].cs_buf[0] = 0;
16244 css_buf_unicode[j + 1].cs_len = 1;
16245 }
16246
16247 free (css_buf);
16248
16249 css_buf = css_buf_unicode;
16250 css_cnt = css_cnt_unicode;
16251 }
16252
16253 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
16254
16255 uint mask_min = pw_min;
16256 uint mask_max = pw_max;
16257
16258 if (opts_type & OPTS_TYPE_PT_UNICODE)
16259 {
16260 mask_min *= 2;
16261 mask_max *= 2;
16262 }
16263
16264 if ((css_cnt < mask_min) || (css_cnt > mask_max))
16265 {
16266 if (css_cnt < mask_min)
16267 {
16268 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
16269 }
16270
16271 if (css_cnt > mask_max)
16272 {
16273 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
16274 }
16275
16276 // skip to next mask
16277
16278 dictpos++;
16279
16280 rd->dictpos = dictpos;
16281
16282 logfile_sub_msg ("STOP");
16283
16284 continue;
16285 }
16286
16287 uint save_css_cnt = css_cnt;
16288
16289 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16290 {
16291 if (opti_type & OPTI_TYPE_APPENDED_SALT)
16292 {
16293 uint salt_len = (uint) data.salts_buf[0].salt_len;
16294 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
16295
16296 uint css_cnt_salt = css_cnt + salt_len;
16297
16298 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
16299
16300 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
16301
16302 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
16303 {
16304 css_buf_salt[j].cs_buf[0] = salt_buf[i];
16305 css_buf_salt[j].cs_len = 1;
16306 }
16307
16308 free (css_buf);
16309
16310 css_buf = css_buf_salt;
16311 css_cnt = css_cnt_salt;
16312 }
16313 }
16314
16315 data.mask = mask;
16316 data.css_cnt = css_cnt;
16317 data.css_buf = css_buf;
16318
16319 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
16320
16321 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16322
16323 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16324
16325 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16326 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16327
16328 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16329
16330 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16331
16332 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16333 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16334
16335 data.root_css_buf = root_css_buf;
16336 data.markov_css_buf = markov_css_buf;
16337
16338 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16339
16340 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16341
16342 local_free (root_table_buf);
16343 local_free (markov_table_buf);
16344
16345 // copy + args
16346
16347 uint css_cnt_l = css_cnt;
16348 uint css_cnt_r;
16349
16350 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16351 {
16352 if (save_css_cnt < 6)
16353 {
16354 css_cnt_r = 1;
16355 }
16356 else if (save_css_cnt == 6)
16357 {
16358 css_cnt_r = 2;
16359 }
16360 else
16361 {
16362 if (opts_type & OPTS_TYPE_PT_UNICODE)
16363 {
16364 if (save_css_cnt == 8 || save_css_cnt == 10)
16365 {
16366 css_cnt_r = 2;
16367 }
16368 else
16369 {
16370 css_cnt_r = 4;
16371 }
16372 }
16373 else
16374 {
16375 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
16376 {
16377 css_cnt_r = 3;
16378 }
16379 else
16380 {
16381 css_cnt_r = 4;
16382 }
16383 }
16384 }
16385 }
16386 else
16387 {
16388 css_cnt_r = 1;
16389
16390 /* unfinished code?
16391 int sum = css_buf[css_cnt_r - 1].cs_len;
16392
16393 for (uint i = 1; i < 4 && i < css_cnt; i++)
16394 {
16395 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
16396
16397 css_cnt_r++;
16398
16399 sum *= css_buf[css_cnt_r - 1].cs_len;
16400 }
16401 */
16402 }
16403
16404 css_cnt_l -= css_cnt_r;
16405
16406 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
16407
16408 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16409 {
16410 hc_device_param_t *device_param = &data.devices_param[device_id];
16411
16412 if (device_param->skipped) continue;
16413
16414 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
16415 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
16416 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
16417
16418 device_param->kernel_params_mp_l_buf64[3] = 0;
16419 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
16420 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
16421 device_param->kernel_params_mp_l_buf32[6] = 0;
16422 device_param->kernel_params_mp_l_buf32[7] = 0;
16423 device_param->kernel_params_mp_l_buf32[8] = 0;
16424
16425 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
16426 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
16427 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
16428 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
16429
16430 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
16431 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
16432 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
16433
16434 device_param->kernel_params_mp_r_buf64[3] = 0;
16435 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
16436 device_param->kernel_params_mp_r_buf32[5] = 0;
16437 device_param->kernel_params_mp_r_buf32[6] = 0;
16438 device_param->kernel_params_mp_r_buf32[7] = 0;
16439
16440 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]);
16441 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]);
16442 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]);
16443
16444 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]);
16445 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]);
16446 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]);
16447
16448 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);
16449 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);
16450 }
16451 }
16452
16453 u64 words_base = data.words_cnt;
16454
16455 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16456 {
16457 if (data.kernel_rules_cnt)
16458 {
16459 words_base /= data.kernel_rules_cnt;
16460 }
16461 }
16462 else if (data.attack_kern == ATTACK_KERN_COMBI)
16463 {
16464 if (data.combs_cnt)
16465 {
16466 words_base /= data.combs_cnt;
16467 }
16468 }
16469 else if (data.attack_kern == ATTACK_KERN_BF)
16470 {
16471 if (data.bfs_cnt)
16472 {
16473 words_base /= data.bfs_cnt;
16474 }
16475 }
16476
16477 data.words_base = words_base;
16478
16479 if (keyspace == 1)
16480 {
16481 log_info ("%llu", (unsigned long long int) words_base);
16482
16483 return (0);
16484 }
16485
16486 if (data.words_cur > data.words_base)
16487 {
16488 log_error ("ERROR: restore value greater keyspace");
16489
16490 return (-1);
16491 }
16492
16493 if (data.words_cur)
16494 {
16495 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16496 {
16497 for (uint i = 0; i < data.salts_cnt; i++)
16498 {
16499 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16500 }
16501 }
16502 else if (data.attack_kern == ATTACK_KERN_COMBI)
16503 {
16504 for (uint i = 0; i < data.salts_cnt; i++)
16505 {
16506 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16507 }
16508 }
16509 else if (data.attack_kern == ATTACK_KERN_BF)
16510 {
16511 for (uint i = 0; i < data.salts_cnt; i++)
16512 {
16513 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16514 }
16515 }
16516 }
16517
16518 /*
16519 * Inform user about possible slow speeds
16520 */
16521
16522 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16523 {
16524 if (data.words_base < kernel_power_all)
16525 {
16526 if (quiet == 0)
16527 {
16528 log_info ("");
16529 log_info ("ATTENTION!");
16530 log_info (" The wordlist or mask you are using is too small.");
16531 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
16532 log_info (" The cracking speed will drop.");
16533 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16534 log_info ("");
16535 }
16536 }
16537 }
16538
16539 /*
16540 * Update loopback file
16541 */
16542
16543 if (loopback == 1)
16544 {
16545 time_t now;
16546
16547 time (&now);
16548
16549 uint random_num = get_random_num (0, 9999);
16550
16551 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16552
16553 data.loopback_file = loopback_file;
16554 }
16555
16556 /*
16557 * Update dictionary statistic
16558 */
16559
16560 if (keyspace == 0)
16561 {
16562 dictstat_fp = fopen (dictstat, "wb");
16563
16564 if (dictstat_fp)
16565 {
16566 lock_file (dictstat_fp);
16567
16568 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16569
16570 fclose (dictstat_fp);
16571 }
16572 }
16573
16574 data.devices_status = STATUS_RUNNING;
16575
16576 if (initial_restore_done == 0)
16577 {
16578 if (data.restore_disable == 0) cycle_restore ();
16579
16580 initial_restore_done = 1;
16581 }
16582
16583 hc_timer_set (&data.timer_running);
16584
16585 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16586 {
16587 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16588 {
16589 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16590 if (quiet == 0) fflush (stdout);
16591 }
16592 }
16593 else if (wordlist_mode == WL_MODE_STDIN)
16594 {
16595 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16596 if (data.quiet == 0) log_info ("");
16597 }
16598
16599 time_t runtime_start;
16600
16601 time (&runtime_start);
16602
16603 data.runtime_start = runtime_start;
16604
16605 /**
16606 * create cracker threads
16607 */
16608
16609 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
16610
16611 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16612 {
16613 hc_device_param_t *device_param = &devices_param[device_id];
16614
16615 if (wordlist_mode == WL_MODE_STDIN)
16616 {
16617 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16618 }
16619 else
16620 {
16621 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16622 }
16623 }
16624
16625 // wait for crack threads to exit
16626
16627 hc_thread_wait (data.devices_cnt, c_threads);
16628
16629 local_free (c_threads);
16630
16631 data.restore = 0;
16632
16633 // finalize task
16634
16635 logfile_sub_var_uint ("status-after-work", data.devices_status);
16636
16637 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16638
16639 if (data.devices_status == STATUS_CRACKED) break;
16640 if (data.devices_status == STATUS_ABORTED) break;
16641
16642 if (data.devices_status == STATUS_BYPASS)
16643 {
16644 data.devices_status = STATUS_RUNNING;
16645 }
16646
16647 if (induction_dictionaries_cnt)
16648 {
16649 unlink (induction_dictionaries[0]);
16650 }
16651
16652 free (induction_dictionaries);
16653
16654 if (attack_mode != ATTACK_MODE_BF)
16655 {
16656 induction_dictionaries = scan_directory (induction_directory);
16657
16658 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16659 }
16660
16661 if (benchmark == 0)
16662 {
16663 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16664 {
16665 if (quiet == 0) clear_prompt ();
16666
16667 if (quiet == 0) log_info ("");
16668
16669 if (status == 1)
16670 {
16671 status_display ();
16672 }
16673 else
16674 {
16675 if (quiet == 0) status_display ();
16676 }
16677
16678 if (quiet == 0) log_info ("");
16679 }
16680 }
16681
16682 if (attack_mode == ATTACK_MODE_BF)
16683 {
16684 dictpos++;
16685
16686 rd->dictpos = dictpos;
16687 }
16688 else
16689 {
16690 if (induction_dictionaries_cnt)
16691 {
16692 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16693 }
16694 else
16695 {
16696 dictpos++;
16697
16698 rd->dictpos = dictpos;
16699 }
16700 }
16701
16702 time_t runtime_stop;
16703
16704 time (&runtime_stop);
16705
16706 data.runtime_stop = runtime_stop;
16707
16708 logfile_sub_uint (runtime_start);
16709 logfile_sub_uint (runtime_stop);
16710
16711 logfile_sub_msg ("STOP");
16712
16713 global_free (subid);
16714 }
16715
16716 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16717
16718 if (data.devices_status == STATUS_CRACKED) break;
16719 if (data.devices_status == STATUS_ABORTED) break;
16720 if (data.devices_status == STATUS_QUIT) break;
16721
16722 if (data.devices_status == STATUS_BYPASS)
16723 {
16724 data.devices_status = STATUS_RUNNING;
16725 }
16726 }
16727
16728 // 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
16729
16730 if (attack_mode == ATTACK_MODE_STRAIGHT)
16731 {
16732 if (data.wordlist_mode == WL_MODE_FILE)
16733 {
16734 if (data.dictfile == NULL)
16735 {
16736 if (dictfiles != NULL)
16737 {
16738 data.dictfile = dictfiles[0];
16739
16740 hc_timer_set (&data.timer_running);
16741 }
16742 }
16743 }
16744 }
16745 // NOTE: combi is okay because it is already set beforehand
16746 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16747 {
16748 if (data.dictfile == NULL)
16749 {
16750 if (dictfiles != NULL)
16751 {
16752 hc_timer_set (&data.timer_running);
16753
16754 data.dictfile = dictfiles[0];
16755 }
16756 }
16757 }
16758 else if (attack_mode == ATTACK_MODE_BF)
16759 {
16760 if (data.mask == NULL)
16761 {
16762 hc_timer_set (&data.timer_running);
16763
16764 data.mask = masks[0];
16765 }
16766 }
16767
16768 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16769 {
16770 data.devices_status = STATUS_EXHAUSTED;
16771 }
16772
16773 // if cracked / aborted remove last induction dictionary
16774
16775 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16776 {
16777 struct stat induct_stat;
16778
16779 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16780 {
16781 unlink (induction_dictionaries[file_pos]);
16782 }
16783 }
16784
16785 // wait for non-interactive threads
16786
16787 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16788 {
16789 hc_thread_wait (1, &ni_threads[thread_idx]);
16790 }
16791
16792 local_free (ni_threads);
16793
16794 // wait for interactive threads
16795
16796 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16797 {
16798 hc_thread_wait (1, &i_thread);
16799 }
16800
16801 // we dont need restore file anymore
16802 if (data.restore_disable == 0)
16803 {
16804 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16805 {
16806 unlink (eff_restore_file);
16807 unlink (new_restore_file);
16808 }
16809 else
16810 {
16811 cycle_restore ();
16812 }
16813 }
16814
16815 // finally save left hashes
16816
16817 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16818 {
16819 save_hash ();
16820 }
16821
16822 /**
16823 * Clean up
16824 */
16825
16826 if (benchmark == 1)
16827 {
16828 status_benchmark ();
16829
16830 log_info ("");
16831 }
16832 else
16833 {
16834 if (quiet == 0) clear_prompt ();
16835
16836 if (quiet == 0) log_info ("");
16837
16838 if (status == 1)
16839 {
16840 status_display ();
16841 }
16842 else
16843 {
16844 if (quiet == 0) status_display ();
16845 }
16846
16847 if (quiet == 0) log_info ("");
16848 }
16849
16850 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16851 {
16852 hc_device_param_t *device_param = &data.devices_param[device_id];
16853
16854 if (device_param->skipped) continue;
16855
16856 local_free (device_param->result);
16857
16858 local_free (device_param->combs_buf);
16859
16860 local_free (device_param->hooks_buf);
16861
16862 local_free (device_param->device_name);
16863
16864 local_free (device_param->device_name_chksum);
16865
16866 local_free (device_param->device_version);
16867
16868 local_free (device_param->driver_version);
16869
16870 if (device_param->pws_buf) myfree (device_param->pws_buf);
16871 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
16872 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
16873 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
16874 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
16875 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
16876 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
16877 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
16878 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
16879 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
16880 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
16881 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
16882 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
16883 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
16884 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
16885 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
16886 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
16887 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
16888 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
16889 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
16890 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
16891 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
16892 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
16893 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
16894 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
16895 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
16896 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
16897 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
16898 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
16899
16900 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
16901 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
16902 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
16903 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
16904 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
16905 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
16906 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
16907 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
16908 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
16909 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
16910
16911 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
16912 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
16913 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
16914
16915 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
16916 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
16917 }
16918
16919 // reset default fan speed
16920
16921 #ifdef HAVE_HWMON
16922 if (gpu_temp_disable == 0)
16923 {
16924 #ifdef HAVE_ADL
16925 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16926 {
16927 hc_thread_mutex_lock (mux_adl);
16928
16929 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16930 {
16931 hc_device_param_t *device_param = &data.devices_param[device_id];
16932
16933 if (device_param->skipped) continue;
16934
16935 if (data.hm_device[device_id].fan_supported == 1)
16936 {
16937 int fanspeed = temp_retain_fanspeed_value[device_id];
16938
16939 if (fanspeed == -1) continue;
16940
16941 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
16942
16943 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
16944 }
16945 }
16946
16947 hc_thread_mutex_unlock (mux_adl);
16948 }
16949 #endif // HAVE_ADL
16950 }
16951
16952 #ifdef HAVE_ADL
16953 // reset power tuning
16954
16955 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16956 {
16957 hc_thread_mutex_lock (mux_adl);
16958
16959 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16960 {
16961 hc_device_param_t *device_param = &data.devices_param[device_id];
16962
16963 if (device_param->skipped) continue;
16964
16965 if (data.hm_device[device_id].od_version == 6)
16966 {
16967 // check powertune capabilities first, if not available then skip device
16968
16969 int powertune_supported = 0;
16970
16971 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
16972 {
16973 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16974
16975 return (-1);
16976 }
16977
16978 if (powertune_supported != 0)
16979 {
16980 // powercontrol settings
16981
16982 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)
16983 {
16984 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16985
16986 return (-1);
16987 }
16988
16989 // clocks
16990
16991 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16992
16993 performance_state->iNumberOfPerformanceLevels = 2;
16994
16995 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
16996 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
16997 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
16998 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
16999
17000 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)
17001 {
17002 log_info ("ERROR: Failed to restore ADL performance state");
17003
17004 return (-1);
17005 }
17006
17007 local_free (performance_state);
17008 }
17009 }
17010 }
17011
17012 hc_thread_mutex_unlock (mux_adl);
17013 }
17014 #endif // HAVE_ADL
17015
17016 if (gpu_temp_disable == 0)
17017 {
17018 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
17019 if (data.hm_nv)
17020 {
17021 #if defined(LINUX) && defined(HAVE_NVML)
17022
17023 hm_NVML_nvmlShutdown (data.hm_nv);
17024
17025 nvml_close (data.hm_nv);
17026
17027 #elif defined(WIN) && (HAVE_NVAPI)
17028
17029 hm_NvAPI_Unload (data.hm_nv);
17030
17031 nvapi_close (data.hm_nv);
17032
17033 #endif
17034
17035 data.hm_nv = NULL;
17036 }
17037 #endif
17038
17039 #ifdef HAVE_ADL
17040 if (data.hm_amd)
17041 {
17042 hm_ADL_Main_Control_Destroy (data.hm_amd);
17043
17044 adl_close (data.hm_amd);
17045 data.hm_amd = NULL;
17046 }
17047 #endif
17048 }
17049 #endif // HAVE_HWMON
17050
17051 // free memory
17052
17053 local_free (masks);
17054
17055 local_free (dictstat_base);
17056
17057 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
17058 {
17059 pot_t *pot_ptr = &pot[pot_pos];
17060
17061 hash_t *hash = &pot_ptr->hash;
17062
17063 local_free (hash->digest);
17064
17065 if (isSalted)
17066 {
17067 local_free (hash->salt);
17068 }
17069 }
17070
17071 local_free (pot);
17072
17073 local_free (all_kernel_rules_cnt);
17074 local_free (all_kernel_rules_buf);
17075
17076 local_free (wl_data->buf);
17077 local_free (wl_data);
17078
17079 local_free (bitmap_s1_a);
17080 local_free (bitmap_s1_b);
17081 local_free (bitmap_s1_c);
17082 local_free (bitmap_s1_d);
17083 local_free (bitmap_s2_a);
17084 local_free (bitmap_s2_b);
17085 local_free (bitmap_s2_c);
17086 local_free (bitmap_s2_d);
17087
17088 #ifdef HAVE_HWMON
17089 local_free (temp_retain_fanspeed_value);
17090 #ifdef HAVE_ADL
17091 local_free (od_clock_mem_status);
17092 local_free (od_power_control_status);
17093 #endif // ADL
17094 #endif
17095
17096 global_free (devices_param);
17097
17098 global_free (kernel_rules_buf);
17099
17100 global_free (root_css_buf);
17101 global_free (markov_css_buf);
17102
17103 global_free (digests_buf);
17104 global_free (digests_shown);
17105 global_free (digests_shown_tmp);
17106
17107 global_free (salts_buf);
17108 global_free (salts_shown);
17109
17110 global_free (esalts_buf);
17111
17112 global_free (words_progress_done);
17113 global_free (words_progress_rejected);
17114 global_free (words_progress_restored);
17115
17116 if (pot_fp) fclose (pot_fp);
17117
17118 if (data.devices_status == STATUS_QUIT) break;
17119 }
17120
17121 // destroy others mutex
17122
17123 hc_thread_mutex_delete (mux_dispatcher);
17124 hc_thread_mutex_delete (mux_counter);
17125 hc_thread_mutex_delete (mux_display);
17126 hc_thread_mutex_delete (mux_adl);
17127
17128 // free memory
17129
17130 local_free (eff_restore_file);
17131 local_free (new_restore_file);
17132
17133 local_free (rd);
17134
17135 // tuning db
17136
17137 tuning_db_destroy (tuning_db);
17138
17139 // loopback
17140
17141 local_free (loopback_file);
17142
17143 if (loopback == 1) unlink (loopback_file);
17144
17145 // induction directory
17146
17147 if (induction_dir == NULL)
17148 {
17149 if (attack_mode != ATTACK_MODE_BF)
17150 {
17151 if (rmdir (induction_directory) == -1)
17152 {
17153 if (errno == ENOENT)
17154 {
17155 // good, we can ignore
17156 }
17157 else if (errno == ENOTEMPTY)
17158 {
17159 // good, we can ignore
17160 }
17161 else
17162 {
17163 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
17164
17165 return (-1);
17166 }
17167 }
17168
17169 local_free (induction_directory);
17170 }
17171 }
17172
17173 // outfile-check directory
17174
17175 if (outfile_check_dir == NULL)
17176 {
17177 if (rmdir (outfile_check_directory) == -1)
17178 {
17179 if (errno == ENOENT)
17180 {
17181 // good, we can ignore
17182 }
17183 else if (errno == ENOTEMPTY)
17184 {
17185 // good, we can ignore
17186 }
17187 else
17188 {
17189 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
17190
17191 return (-1);
17192 }
17193 }
17194
17195 local_free (outfile_check_directory);
17196 }
17197
17198 time_t proc_stop;
17199
17200 time (&proc_stop);
17201
17202 logfile_top_uint (proc_start);
17203 logfile_top_uint (proc_stop);
17204
17205 logfile_top_msg ("STOP");
17206
17207 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
17208 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
17209
17210 if (data.ocl) ocl_close (data.ocl);
17211
17212 if (data.devices_status == STATUS_ABORTED) return 2;
17213 if (data.devices_status == STATUS_QUIT) return 2;
17214 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
17215 if (data.devices_status == STATUS_EXHAUSTED) return 1;
17216 if (data.devices_status == STATUS_CRACKED) return 0;
17217
17218 return -1;
17219 }
Hashcat additions to support pwdhash