projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Balancing the workload turns out to be very efficient
[hashcat.git] / src / hashcat.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 = "hashcat";
19 const uint VERSION_BIN = 300;
20 const uint RESTORE_MIN = 300;
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 RESTORE 0
37 #define RESTORE_TIMER 60
38 #define RESTORE_DISABLE 0
39 #define STATUS 0
40 #define STATUS_TIMER 10
41 #define STATUS_AUTOMAT 0
42 #define LOOPBACK 0
43 #define WEAK_HASH_THRESHOLD 100
44 #define SHOW 0
45 #define LEFT 0
46 #define USERNAME 0
47 #define REMOVE 0
48 #define REMOVE_TIMER 60
49 #define SKIP 0
50 #define LIMIT 0
51 #define KEYSPACE 0
52 #define POTFILE_DISABLE 0
53 #define DEBUG_MODE 0
54 #define RP_GEN 0
55 #define RP_GEN_FUNC_MIN 1
56 #define RP_GEN_FUNC_MAX 4
57 #define RP_GEN_SEED 0
58 #define RULE_BUF_L ":"
59 #define RULE_BUF_R ":"
60 #define FORCE 0
61 #define RUNTIME 0
62 #define HEX_CHARSET 0
63 #define HEX_SALT 0
64 #define HEX_WORDLIST 0
65 #define OUTFILE_FORMAT 3
66 #define OUTFILE_AUTOHEX 1
67 #define OUTFILE_CHECK_TIMER 5
68 #define ATTACK_MODE 0
69 #define HASH_MODE 0
70 #define SEGMENT_SIZE 32
71 #define INCREMENT 0
72 #define INCREMENT_MIN 1
73 #define INCREMENT_MAX PW_MAX
74 #define SEPARATOR ':'
75 #define BITMAP_MIN 16
76 #define BITMAP_MAX 24
77 #define GPU_TEMP_DISABLE 0
78 #define GPU_TEMP_ABORT 90
79 #define GPU_TEMP_RETAIN 80
80 #define WORKLOAD_PROFILE 2
81 #define KERNEL_ACCEL 0
82 #define KERNEL_LOOPS 0
83 #define KERNEL_RULES 1024
84 #define KERNEL_COMBS 1024
85 #define KERNEL_BFS 1024
86 #define KERNEL_THREADS_MAX 256
87 #define KERNEL_THREADS_MAX_CPU 16
88 #define POWERTUNE_ENABLE 0
89 #define LOGFILE_DISABLE 0
90 #define SCRYPT_TMTO 0
91 #define OPENCL_VECTOR_WIDTH 0
92
93 #define WL_MODE_STDIN 1
94 #define WL_MODE_FILE 2
95 #define WL_MODE_MASK 3
96
97 #define HL_MODE_FILE 4
98 #define HL_MODE_ARG 5
99
100 #define HLFMTS_CNT 11
101 #define HLFMT_HASHCAT 0
102 #define HLFMT_PWDUMP 1
103 #define HLFMT_PASSWD 2
104 #define HLFMT_SHADOW 3
105 #define HLFMT_DCC 4
106 #define HLFMT_DCC2 5
107 #define HLFMT_NETNTLM1 7
108 #define HLFMT_NETNTLM2 8
109 #define HLFMT_NSLDAP 9
110 #define HLFMT_NSLDAPS 10
111
112 #define HLFMT_TEXT_HASHCAT "native hashcat"
113 #define HLFMT_TEXT_PWDUMP "pwdump"
114 #define HLFMT_TEXT_PASSWD "passwd"
115 #define HLFMT_TEXT_SHADOW "shadow"
116 #define HLFMT_TEXT_DCC "DCC"
117 #define HLFMT_TEXT_DCC2 "DCC 2"
118 #define HLFMT_TEXT_NETNTLM1 "NetNTLMv1"
119 #define HLFMT_TEXT_NETNTLM2 "NetNTLMv2"
120 #define HLFMT_TEXT_NSLDAP "nsldap"
121 #define HLFMT_TEXT_NSLDAPS "nsldaps"
122
123 #define ATTACK_MODE_STRAIGHT 0
124 #define ATTACK_MODE_COMBI 1
125 #define ATTACK_MODE_TOGGLE 2
126 #define ATTACK_MODE_BF 3
127 #define ATTACK_MODE_PERM 4
128 #define ATTACK_MODE_TABLE 5
129 #define ATTACK_MODE_HYBRID1 6
130 #define ATTACK_MODE_HYBRID2 7
131 #define ATTACK_MODE_NONE 100
132
133 #define ATTACK_KERN_STRAIGHT 0
134 #define ATTACK_KERN_COMBI 1
135 #define ATTACK_KERN_BF 3
136 #define ATTACK_KERN_NONE 100
137
138 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
139 #define ATTACK_EXEC_INSIDE_KERNEL 11
140
141 #define COMBINATOR_MODE_BASE_LEFT 10001
142 #define COMBINATOR_MODE_BASE_RIGHT 10002
143
144 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
145 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
146
147 #define MAX_CUT_TRIES 4
148
149 #define MAX_DICTSTAT 10000
150
151 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 136
152
153 #define global_free(attr) \
154 { \
155 myfree ((void *) data.attr); \
156 \
157 data.attr = NULL; \
158 }
159
160 #define local_free(attr) \
161 { \
162 myfree ((void *) attr); \
163 \
164 attr = NULL; \
165 }
166
167 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
168 {
169 900,
170 0,
171 5100,
172 100,
173 1400,
174 10800,
175 1700,
176 5000,
177 10100,
178 6000,
179 6100,
180 6900,
181 11700,
182 11800,
183 400,
184 8900,
185 11900,
186 12000,
187 10900,
188 12100,
189 23,
190 2500,
191 5300,
192 5400,
193 5500,
194 5600,
195 7300,
196 7500,
197 13100,
198 8300,
199 11100,
200 11200,
201 11400,
202 121,
203 2611,
204 2711,
205 2811,
206 8400,
207 11,
208 2612,
209 7900,
210 21,
211 11000,
212 124,
213 10000,
214 3711,
215 7600,
216 12,
217 131,
218 132,
219 1731,
220 200,
221 300,
222 3100,
223 112,
224 12300,
225 8000,
226 141,
227 1441,
228 1600,
229 12600,
230 1421,
231 101,
232 111,
233 1711,
234 3000,
235 1000,
236 1100,
237 2100,
238 12800,
239 1500,
240 12400,
241 500,
242 3200,
243 7400,
244 1800,
245 122,
246 1722,
247 7100,
248 6300,
249 6700,
250 6400,
251 6500,
252 2400,
253 2410,
254 5700,
255 9200,
256 9300,
257 22,
258 501,
259 5800,
260 8100,
261 8500,
262 7200,
263 9900,
264 7700,
265 7800,
266 10300,
267 8600,
268 8700,
269 9100,
270 133,
271 13500,
272 11600,
273 12500,
274 13000,
275 13200,
276 13300,
277 6211,
278 6221,
279 6231,
280 6241,
281 8800,
282 12900,
283 12200,
284 9700,
285 9710,
286 9800,
287 9810,
288 9400,
289 9500,
290 9600,
291 10400,
292 10410,
293 10500,
294 10600,
295 10700,
296 9000,
297 5200,
298 6800,
299 6600,
300 8200,
301 11300,
302 12700,
303 13400,
304 125
305 };
306
307 /**
308 * types
309 */
310
311 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
312
313 /**
314 * globals
315 */
316
317 static unsigned int full01 = 0x01010101;
318 static unsigned int full80 = 0x80808080;
319
320 int SUPPRESS_OUTPUT = 0;
321
322 hc_thread_mutex_t mux_adl;
323 hc_thread_mutex_t mux_counter;
324 hc_thread_mutex_t mux_dispatcher;
325 hc_thread_mutex_t mux_display;
326
327 hc_global_data_t data;
328
329 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
330
331 const char *USAGE_MINI[] =
332 {
333 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
334 "",
335 "Try --help for more help.",
336 NULL
337 };
338
339 const char *USAGE_BIG[] =
340 {
341 "%s, advanced password recovery",
342 "",
343 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
344 "",
345 "=======",
346 "Options",
347 "=======",
348 "",
349 "* General:",
350 "",
351 " -m, --hash-type=NUM Hash-type, see references below",
352 " -a, --attack-mode=NUM Attack-mode, see references below",
353 " -V, --version Print version",
354 " -h, --help Print help",
355 " --quiet Suppress output",
356 "",
357 "* Misc:",
358 "",
359 " --hex-charset Assume charset is given in hex",
360 " --hex-salt Assume salt is given in hex",
361 " --hex-wordlist Assume words in wordlist is given in hex",
362 " --force Ignore warnings",
363 " --status Enable automatic update of the status-screen",
364 " --status-timer=NUM Seconds between status-screen update",
365 " --status-automat Display the status view in a machine readable format",
366 " --loopback Add new plains to induct directory",
367 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
368 "",
369 "* Markov:",
370 "",
371 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
372 " --markov-disable Disables markov-chains, emulates classic brute-force",
373 " --markov-classic Enables classic markov-chains, no per-position enhancement",
374 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
375 "",
376 "* Session:",
377 "",
378 " --runtime=NUM Abort session after NUM seconds of runtime",
379 " --session=STR Define specific session name",
380 " --restore Restore session from --session",
381 " --restore-disable Do not write restore file",
382 "",
383 "* Files:",
384 "",
385 " -o, --outfile=FILE Define outfile for recovered hash",
386 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
387 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
388 " --outfile-check-timer=NUM Seconds between outfile checks",
389 " -p, --separator=CHAR Separator char for hashlists and outfile",
390 " --show Show cracked passwords only",
391 " --left Show un-cracked passwords only",
392 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
393 " --remove Enable remove of hash once it is cracked",
394 " --remove-timer=NUM Update input hash file each NUM seconds",
395 " --potfile-disable Do not write potfile",
396 " --potfile-path Specific path to potfile",
397 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
398 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
399 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
400 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
401 " --logfile-disable Disable the logfile",
402 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
403 "",
404 "* Resources:",
405 "",
406 " -b, --benchmark Run benchmark",
407 " --benchmark-repeats=NUM Repeat the kernel on the device NUM times to increase benchmark accuracy",
408 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
409 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
410 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
411 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
412 " --opencl-platforms=STR OpenCL platforms to use, separate with comma",
413 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
414 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
415 " --opencl-vector-width=NUM OpenCL vector-width (either 1, 2, 4, 8 or 16), overrides value from device query",
416 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
417 " -n, --kernel-accel=NUM Workload tuning, increase the outer-loop step size",
418 " -u, --kernel-loops=NUM Workload tuning, increase the inner-loop step size",
419 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
420 #ifdef HAVE_HWMON
421 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
422 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
423 #ifdef HAVE_ADL
424 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
425 #endif
426 #endif
427 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
428 "",
429 "* Distributed:",
430 "",
431 " -s, --skip=NUM Skip number of words",
432 " -l, --limit=NUM Limit number of words",
433 " --keyspace Show keyspace base:mod values and quit",
434 "",
435 "* Rules:",
436 "",
437 " -j, --rule-left=RULE Single rule applied to each word from left dict",
438 " -k, --rule-right=RULE Single rule applied to each word from right dict",
439 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
440 " -g, --generate-rules=NUM Generate NUM random rules",
441 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
442 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
443 " --generate-rules-seed=NUM Force RNG seed to NUM",
444 "",
445 "* Custom charsets:",
446 "",
447 " -1, --custom-charset1=CS User-defined charsets",
448 " -2, --custom-charset2=CS Example:",
449 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
450 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
451 "",
452 "* Increment:",
453 "",
454 " -i, --increment Enable increment mode",
455 " --increment-min=NUM Start incrementing at NUM",
456 " --increment-max=NUM Stop incrementing at NUM",
457 "",
458 "==========",
459 "References",
460 "==========",
461 "",
462 "* Workload Profile:",
463 "",
464 " 1 = Interactive performance profile, kernel execution runtime to 8ms, lower latency desktop, lower speed",
465 " 2 = Default performance profile, kernel execution runtime to 16ms, economic setting",
466 " 3 = Headless performance profile, kernel execution runtime to 96ms, higher latency desktop, higher speed",
467 "",
468 "* OpenCL device-types:",
469 "",
470 " 1 = CPU devices",
471 " 2 = GPU devices",
472 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
473 "",
474 "* Outfile Formats:",
475 "",
476 " 1 = hash[:salt]",
477 " 2 = plain",
478 " 3 = hash[:salt]:plain",
479 " 4 = hex_plain",
480 " 5 = hash[:salt]:hex_plain",
481 " 6 = plain:hex_plain",
482 " 7 = hash[:salt]:plain:hex_plain",
483 " 8 = crackpos",
484 " 9 = hash[:salt]:crackpos",
485 " 10 = plain:crackpos",
486 " 11 = hash[:salt]:plain:crackpos",
487 " 12 = hex_plain:crackpos",
488 " 13 = hash[:salt]:hex_plain:crackpos",
489 " 14 = plain:hex_plain:crackpos",
490 " 15 = hash[:salt]:plain:hex_plain:crackpos",
491 "",
492 "* Debug mode output formats (for hybrid mode only, by using rules):",
493 "",
494 " 1 = save finding rule",
495 " 2 = save original word",
496 " 3 = save original word and finding rule",
497 " 4 = save original word, finding rule and modified plain",
498 "",
499 "* Built-in charsets:",
500 "",
501 " ?l = abcdefghijklmnopqrstuvwxyz",
502 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
503 " ?d = 0123456789",
504 " ?s = !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
505 " ?a = ?l?u?d?s",
506 " ?b = 0x00 - 0xff",
507 "",
508 "* Attack modes:",
509 "",
510 " 0 = Straight",
511 " 1 = Combination",
512 " 3 = Brute-force",
513 " 6 = Hybrid dict + mask",
514 " 7 = Hybrid mask + dict",
515 "",
516 "* Hash types:",
517 "",
518 "[[ Roll-your-own: Raw Hashes ]]",
519 "",
520 " 900 = MD4",
521 " 0 = MD5",
522 " 5100 = Half MD5",
523 " 100 = SHA1",
524 " 10800 = SHA-384",
525 " 1400 = SHA-256",
526 " 1700 = SHA-512",
527 " 5000 = SHA-3(Keccak)",
528 " 10100 = SipHash",
529 " 6000 = RipeMD160",
530 " 6100 = Whirlpool",
531 " 6900 = GOST R 34.11-94",
532 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
533 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
534 "",
535 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
536 "",
537 " 10 = md5($pass.$salt)",
538 " 20 = md5($salt.$pass)",
539 " 30 = md5(unicode($pass).$salt)",
540 " 40 = md5($salt.unicode($pass))",
541 " 3800 = md5($salt.$pass.$salt)",
542 " 3710 = md5($salt.md5($pass))",
543 " 2600 = md5(md5($pass)",
544 " 4300 = md5(strtoupper(md5($pass)))",
545 " 4400 = md5(sha1($pass))",
546 " 110 = sha1($pass.$salt)",
547 " 120 = sha1($salt.$pass)",
548 " 130 = sha1(unicode($pass).$salt)",
549 " 140 = sha1($salt.unicode($pass))",
550 " 4500 = sha1(sha1($pass)",
551 " 4700 = sha1(md5($pass))",
552 " 4900 = sha1($salt.$pass.$salt)",
553 " 1410 = sha256($pass.$salt)",
554 " 1420 = sha256($salt.$pass)",
555 " 1430 = sha256(unicode($pass).$salt)",
556 " 1440 = sha256($salt.unicode($pass))",
557 " 1710 = sha512($pass.$salt)",
558 " 1720 = sha512($salt.$pass)",
559 " 1730 = sha512(unicode($pass).$salt)",
560 " 1740 = sha512($salt.unicode($pass))",
561 "",
562 "[[ Roll-your-own: Authenticated Hashes ]]",
563 "",
564 " 50 = HMAC-MD5 (key = $pass)",
565 " 60 = HMAC-MD5 (key = $salt)",
566 " 150 = HMAC-SHA1 (key = $pass)",
567 " 160 = HMAC-SHA1 (key = $salt)",
568 " 1450 = HMAC-SHA256 (key = $pass)",
569 " 1460 = HMAC-SHA256 (key = $salt)",
570 " 1750 = HMAC-SHA512 (key = $pass)",
571 " 1760 = HMAC-SHA512 (key = $salt)",
572 "",
573 "[[ Generic KDF ]]",
574 "",
575 " 400 = phpass",
576 " 8900 = scrypt",
577 " 11900 = PBKDF2-HMAC-MD5",
578 " 12000 = PBKDF2-HMAC-SHA1",
579 " 10900 = PBKDF2-HMAC-SHA256",
580 " 12100 = PBKDF2-HMAC-SHA512",
581 "",
582 "[[ Network protocols, Challenge-Response ]]",
583 "",
584 " 23 = Skype",
585 " 2500 = WPA/WPA2",
586 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
587 " 5300 = IKE-PSK MD5",
588 " 5400 = IKE-PSK SHA1",
589 " 5500 = NetNTLMv1",
590 " 5500 = NetNTLMv1 + ESS",
591 " 5600 = NetNTLMv2",
592 " 7300 = IPMI2 RAKP HMAC-SHA1",
593 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
594 " 8300 = DNSSEC (NSEC3)",
595 " 10200 = Cram MD5",
596 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
597 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
598 " 11400 = SIP digest authentication (MD5)",
599 " 13100 = Kerberos 5 TGS-REP etype 23",
600 "",
601 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
602 "",
603 " 121 = SMF (Simple Machines Forum)",
604 " 400 = phpBB3",
605 " 2611 = vBulletin < v3.8.5",
606 " 2711 = vBulletin > v3.8.5",
607 " 2811 = MyBB",
608 " 2811 = IPB (Invison Power Board)",
609 " 8400 = WBB3 (Woltlab Burning Board)",
610 " 11 = Joomla < 2.5.18",
611 " 400 = Joomla > 2.5.18",
612 " 400 = Wordpress",
613 " 2612 = PHPS",
614 " 7900 = Drupal7",
615 " 21 = osCommerce",
616 " 21 = xt:Commerce",
617 " 11000 = PrestaShop",
618 " 124 = Django (SHA-1)",
619 " 10000 = Django (PBKDF2-SHA256)",
620 " 3711 = Mediawiki B type",
621 " 7600 = Redmine",
622 "",
623 "[[ Database Server ]]",
624 "",
625 " 12 = PostgreSQL",
626 " 131 = MSSQL(2000)",
627 " 132 = MSSQL(2005)",
628 " 1731 = MSSQL(2012)",
629 " 1731 = MSSQL(2014)",
630 " 200 = MySQL323",
631 " 300 = MySQL4.1/MySQL5",
632 " 3100 = Oracle H: Type (Oracle 7+)",
633 " 112 = Oracle S: Type (Oracle 11+)",
634 " 12300 = Oracle T: Type (Oracle 12+)",
635 " 8000 = Sybase ASE",
636 "",
637 "[[ HTTP, SMTP, LDAP Server ]]",
638 "",
639 " 141 = EPiServer 6.x < v4",
640 " 1441 = EPiServer 6.x > v4",
641 " 1600 = Apache $apr1$",
642 " 12600 = ColdFusion 10+",
643 " 1421 = hMailServer",
644 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
645 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
646 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
647 "",
648 "[[ Checksums ]]",
649 "",
650 " 11500 = CRC32",
651 "",
652 "[[ Operating-Systems ]]",
653 "",
654 " 3000 = LM",
655 " 1000 = NTLM",
656 " 1100 = Domain Cached Credentials (DCC), MS Cache",
657 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
658 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
659 " 1500 = descrypt, DES(Unix), Traditional DES",
660 " 12400 = BSDiCrypt, Extended DES",
661 " 500 = md5crypt $1$, MD5(Unix)",
662 " 3200 = bcrypt $2*$, Blowfish(Unix)",
663 " 7400 = sha256crypt $5$, SHA256(Unix)",
664 " 1800 = sha512crypt $6$, SHA512(Unix)",
665 " 122 = OSX v10.4",
666 " 122 = OSX v10.5",
667 " 122 = OSX v10.6",
668 " 1722 = OSX v10.7",
669 " 7100 = OSX v10.8",
670 " 7100 = OSX v10.9",
671 " 7100 = OSX v10.10",
672 " 6300 = AIX {smd5}",
673 " 6700 = AIX {ssha1}",
674 " 6400 = AIX {ssha256}",
675 " 6500 = AIX {ssha512}",
676 " 2400 = Cisco-PIX",
677 " 2410 = Cisco-ASA",
678 " 500 = Cisco-IOS $1$",
679 " 5700 = Cisco-IOS $4$",
680 " 9200 = Cisco-IOS $8$",
681 " 9300 = Cisco-IOS $9$",
682 " 22 = Juniper Netscreen/SSG (ScreenOS)",
683 " 501 = Juniper IVE",
684 " 5800 = Android PIN",
685 " 8100 = Citrix Netscaler",
686 " 8500 = RACF",
687 " 7200 = GRUB 2",
688 " 9900 = Radmin2",
689 " 125 = ArubaOS",
690 "",
691 "[[ Enterprise Application Software (EAS) ]]",
692 "",
693 " 7700 = SAP CODVN B (BCODE)",
694 " 7800 = SAP CODVN F/G (PASSCODE)",
695 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
696 " 8600 = Lotus Notes/Domino 5",
697 " 8700 = Lotus Notes/Domino 6",
698 " 9100 = Lotus Notes/Domino 8",
699 " 133 = PeopleSoft",
700 " 13500 = PeopleSoft Token",
701 "",
702 "[[ Archives ]]",
703 "",
704 " 11600 = 7-Zip",
705 " 12500 = RAR3-hp",
706 " 13000 = RAR5",
707 " 13200 = AxCrypt",
708 " 13300 = AxCrypt in memory SHA1",
709 "",
710 "[[ Full-Disk encryptions (FDE) ]]",
711 "",
712 " 62XY = TrueCrypt 5.0+",
713 " X = 1 = PBKDF2-HMAC-RipeMD160",
714 " X = 2 = PBKDF2-HMAC-SHA512",
715 " X = 3 = PBKDF2-HMAC-Whirlpool",
716 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
717 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
718 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
719 " Y = 3 = XTS 1536 bit (Ciphers: All)",
720 " 8800 = Android FDE < v4.3",
721 " 12900 = Android FDE (Samsung DEK)",
722 " 12200 = eCryptfs",
723 "",
724 "[[ Documents ]]",
725 "",
726 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
727 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
728 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
729 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
730 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
731 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
732 " 9400 = MS Office 2007",
733 " 9500 = MS Office 2010",
734 " 9600 = MS Office 2013",
735 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
736 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
737 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
738 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
739 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
740 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
741 "",
742 "[[ Password Managers ]]",
743 "",
744 " 9000 = Password Safe v2",
745 " 5200 = Password Safe v3",
746 " 6800 = Lastpass",
747 " 6600 = 1Password, agilekeychain",
748 " 8200 = 1Password, cloudkeychain",
749 " 11300 = Bitcoin/Litecoin wallet.dat",
750 " 12700 = Blockchain, My Wallet",
751 " 13400 = Keepass 1 (AES/Twofish) and Keepass 2 (AES)",
752 "",
753 NULL
754 };
755
756 /**
757 * hashcat specific functions
758 */
759
760 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
761 {
762 int exec_pos = (int) device_param->exec_pos - last_num_entries;
763
764 if (exec_pos < 0) exec_pos += EXEC_CACHE;
765
766 double exec_ms_sum = 0;
767
768 int exec_ms_cnt = 0;
769
770 for (int i = 0; i < last_num_entries; i++)
771 {
772 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
773
774 if (exec_ms)
775 {
776 exec_ms_sum += exec_ms;
777
778 exec_ms_cnt++;
779 }
780 }
781
782 if (exec_ms_cnt == 0) return 0;
783
784 return exec_ms_sum / exec_ms_cnt;
785 }
786
787 void status_display_automat ()
788 {
789 FILE *out = stdout;
790
791 fprintf (out, "STATUS\t%u\t", data.devices_status);
792
793 /**
794 * speed new
795 */
796
797 fprintf (out, "SPEED\t");
798
799 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
800 {
801 hc_device_param_t *device_param = &data.devices_param[device_id];
802
803 if (device_param->skipped) continue;
804
805 u64 speed_cnt = 0;
806 double speed_ms = 0;
807
808 for (int i = 0; i < SPEED_CACHE; i++)
809 {
810 speed_cnt += device_param->speed_cnt[i];
811 speed_ms += device_param->speed_ms[i];
812 }
813
814 speed_cnt /= SPEED_CACHE;
815 speed_ms /= SPEED_CACHE;
816
817 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
818 }
819
820 /**
821 * exec time
822 */
823
824 fprintf (out, "EXEC_RUNTIME\t");
825
826 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
827 {
828 hc_device_param_t *device_param = &data.devices_param[device_id];
829
830 if (device_param->skipped) continue;
831
832 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
833
834 fprintf (out, "%f\t", exec_ms_avg);
835 }
836
837 /**
838 * words_cur
839 */
840
841 u64 words_cur = get_lowest_words_done ();
842
843 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
844
845 /**
846 * counter
847 */
848
849 u64 progress_total = data.words_cnt * data.salts_cnt;
850
851 u64 all_done = 0;
852 u64 all_rejected = 0;
853 u64 all_restored = 0;
854
855 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
856 {
857 all_done += data.words_progress_done[salt_pos];
858 all_rejected += data.words_progress_rejected[salt_pos];
859 all_restored += data.words_progress_restored[salt_pos];
860 }
861
862 u64 progress_cur = all_restored + all_done + all_rejected;
863 u64 progress_end = progress_total;
864
865 u64 progress_skip = 0;
866
867 if (data.skip)
868 {
869 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
870
871 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
872 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
873 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
874 }
875
876 if (data.limit)
877 {
878 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
879
880 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
881 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
882 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
883 }
884
885 u64 progress_cur_relative_skip = progress_cur - progress_skip;
886 u64 progress_end_relative_skip = progress_end - progress_skip;
887
888 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
889
890 /**
891 * cracks
892 */
893
894 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
895 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
896
897 /**
898 * temperature
899 */
900
901 #ifdef HAVE_HWMON
902 if (data.gpu_temp_disable == 0)
903 {
904 fprintf (out, "TEMP\t");
905
906 hc_thread_mutex_lock (mux_adl);
907
908 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
909 {
910 hc_device_param_t *device_param = &data.devices_param[device_id];
911
912 if (device_param->skipped) continue;
913
914 int temp = hm_get_temperature_with_device_id (device_id);
915
916 fprintf (out, "%d\t", temp);
917 }
918
919 hc_thread_mutex_unlock (mux_adl);
920 }
921 #endif // HAVE_HWMON
922
923 /**
924 * flush
925 */
926
927 #ifdef _WIN
928 fputc ('\r', out);
929 fputc ('\n', out);
930 #endif
931
932 #ifdef _POSIX
933 fputc ('\n', out);
934 #endif
935
936 fflush (out);
937 }
938
939 void status_display ()
940 {
941 if (data.devices_status == STATUS_INIT) return;
942 if (data.devices_status == STATUS_STARTING) return;
943 if (data.devices_status == STATUS_BYPASS) return;
944
945 if (data.status_automat == 1)
946 {
947 status_display_automat ();
948
949 return;
950 }
951
952 char tmp_buf[1000] = { 0 };
953
954 uint tmp_len = 0;
955
956 log_info ("Session.Name...: %s", data.session);
957
958 char *status_type = strstatus (data.devices_status);
959
960 uint hash_mode = data.hash_mode;
961
962 char *hash_type = strhashtype (hash_mode); // not a bug
963
964 log_info ("Status.........: %s", status_type);
965
966 /**
967 * show rules
968 */
969
970 if (data.rp_files_cnt)
971 {
972 uint i;
973
974 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
975 {
976 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
977 }
978
979 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
980
981 log_info ("Rules.Type.....: %s", tmp_buf);
982
983 tmp_len = 0;
984 }
985
986 if (data.rp_gen)
987 {
988 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
989
990 if (data.rp_gen_seed)
991 {
992 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
993 }
994 }
995
996 /**
997 * show input
998 */
999
1000 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1001 {
1002 if (data.wordlist_mode == WL_MODE_FILE)
1003 {
1004 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
1005 }
1006 else if (data.wordlist_mode == WL_MODE_STDIN)
1007 {
1008 log_info ("Input.Mode.....: Pipe");
1009 }
1010 }
1011 else if (data.attack_mode == ATTACK_MODE_COMBI)
1012 {
1013 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1014 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1015 }
1016 else if (data.attack_mode == ATTACK_MODE_BF)
1017 {
1018 char *mask = data.mask;
1019
1020 if (mask != NULL)
1021 {
1022 uint mask_len = data.css_cnt;
1023
1024 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1025
1026 if (mask_len > 0)
1027 {
1028 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1029 {
1030 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1031 {
1032 mask_len -= data.salts_buf[0].salt_len;
1033 }
1034 }
1035
1036 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1037
1038 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1039 }
1040
1041 if (data.maskcnt > 1)
1042 {
1043 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1044
1045 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1046 }
1047
1048 log_info ("Input.Mode.....: %s", tmp_buf);
1049 }
1050
1051 tmp_len = 0;
1052 }
1053 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1054 {
1055 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1056 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1057 }
1058 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1059 {
1060 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1061 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1062 }
1063
1064 if (data.digests_cnt == 1)
1065 {
1066 if (data.hash_mode == 2500)
1067 {
1068 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1069
1070 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1071 (char *) data.salts_buf[0].salt_buf,
1072 wpa->orig_mac1[0],
1073 wpa->orig_mac1[1],
1074 wpa->orig_mac1[2],
1075 wpa->orig_mac1[3],
1076 wpa->orig_mac1[4],
1077 wpa->orig_mac1[5],
1078 wpa->orig_mac2[0],
1079 wpa->orig_mac2[1],
1080 wpa->orig_mac2[2],
1081 wpa->orig_mac2[3],
1082 wpa->orig_mac2[4],
1083 wpa->orig_mac2[5]);
1084 }
1085 else if (data.hash_mode == 5200)
1086 {
1087 log_info ("Hash.Target....: File (%s)", data.hashfile);
1088 }
1089 else if (data.hash_mode == 9000)
1090 {
1091 log_info ("Hash.Target....: File (%s)", data.hashfile);
1092 }
1093 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1094 {
1095 log_info ("Hash.Target....: File (%s)", data.hashfile);
1096 }
1097 else
1098 {
1099 char out_buf[HCBUFSIZ] = { 0 };
1100
1101 ascii_digest (out_buf, 0, 0);
1102
1103 // limit length
1104 if (strlen (out_buf) > 40)
1105 {
1106 out_buf[41] = '.';
1107 out_buf[42] = '.';
1108 out_buf[43] = '.';
1109 out_buf[44] = 0;
1110 }
1111
1112 log_info ("Hash.Target....: %s", out_buf);
1113 }
1114 }
1115 else
1116 {
1117 if (data.hash_mode == 3000)
1118 {
1119 char out_buf1[32] = { 0 };
1120 char out_buf2[32] = { 0 };
1121
1122 ascii_digest (out_buf1, 0, 0);
1123 ascii_digest (out_buf2, 0, 1);
1124
1125 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1126 }
1127 else
1128 {
1129 log_info ("Hash.Target....: File (%s)", data.hashfile);
1130 }
1131 }
1132
1133 log_info ("Hash.Type......: %s", hash_type);
1134
1135 /**
1136 * speed new
1137 */
1138
1139 u64 speed_cnt[DEVICES_MAX] = { 0 };
1140 double speed_ms[DEVICES_MAX] = { 0 };
1141
1142 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1143 {
1144 hc_device_param_t *device_param = &data.devices_param[device_id];
1145
1146 if (device_param->skipped) continue;
1147
1148 speed_cnt[device_id] = 0;
1149 speed_ms[device_id] = 0;
1150
1151 for (int i = 0; i < SPEED_CACHE; i++)
1152 {
1153 speed_cnt[device_id] += device_param->speed_cnt[i];
1154 speed_ms[device_id] += device_param->speed_ms[i];
1155 }
1156
1157 speed_cnt[device_id] /= SPEED_CACHE;
1158 speed_ms[device_id] /= SPEED_CACHE;
1159 }
1160
1161 float hashes_all_ms = 0;
1162
1163 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1164
1165 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1166 {
1167 hc_device_param_t *device_param = &data.devices_param[device_id];
1168
1169 if (device_param->skipped) continue;
1170
1171 hashes_dev_ms[device_id] = 0;
1172
1173 if (speed_ms[device_id])
1174 {
1175 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1176
1177 hashes_all_ms += hashes_dev_ms[device_id];
1178 }
1179 }
1180
1181 /**
1182 * exec time
1183 */
1184
1185 double exec_all_ms[DEVICES_MAX] = { 0 };
1186
1187 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1188 {
1189 hc_device_param_t *device_param = &data.devices_param[device_id];
1190
1191 if (device_param->skipped) continue;
1192
1193 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1194
1195 exec_all_ms[device_id] = exec_ms_avg;
1196 }
1197
1198 /**
1199 * timers
1200 */
1201
1202 double ms_running = 0;
1203
1204 hc_timer_get (data.timer_running, ms_running);
1205
1206 double ms_paused = data.ms_paused;
1207
1208 if (data.devices_status == STATUS_PAUSED)
1209 {
1210 double ms_paused_tmp = 0;
1211
1212 hc_timer_get (data.timer_paused, ms_paused_tmp);
1213
1214 ms_paused += ms_paused_tmp;
1215 }
1216
1217 #ifdef WIN
1218
1219 __time64_t sec_run = ms_running / 1000;
1220
1221 #else
1222
1223 time_t sec_run = ms_running / 1000;
1224
1225 #endif
1226
1227 if (sec_run)
1228 {
1229 char display_run[32] = { 0 };
1230
1231 struct tm tm_run;
1232
1233 struct tm *tmp = NULL;
1234
1235 #ifdef WIN
1236
1237 tmp = _gmtime64 (&sec_run);
1238
1239 #else
1240
1241 tmp = gmtime (&sec_run);
1242
1243 #endif
1244
1245 if (tmp != NULL)
1246 {
1247 memset (&tm_run, 0, sizeof (tm_run));
1248
1249 memcpy (&tm_run, tmp, sizeof (tm_run));
1250
1251 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1252
1253 char *start = ctime (&data.proc_start);
1254
1255 size_t start_len = strlen (start);
1256
1257 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1258 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1259
1260 log_info ("Time.Started...: %s (%s)", start, display_run);
1261 }
1262 }
1263 else
1264 {
1265 log_info ("Time.Started...: 0 secs");
1266 }
1267
1268 /**
1269 * counters
1270 */
1271
1272 u64 progress_total = data.words_cnt * data.salts_cnt;
1273
1274 u64 all_done = 0;
1275 u64 all_rejected = 0;
1276 u64 all_restored = 0;
1277
1278 u64 progress_noneed = 0;
1279
1280 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1281 {
1282 all_done += data.words_progress_done[salt_pos];
1283 all_rejected += data.words_progress_rejected[salt_pos];
1284 all_restored += data.words_progress_restored[salt_pos];
1285
1286 // Important for ETA only
1287
1288 if (data.salts_shown[salt_pos] == 1)
1289 {
1290 const u64 all = data.words_progress_done[salt_pos]
1291 + data.words_progress_rejected[salt_pos]
1292 + data.words_progress_restored[salt_pos];
1293
1294 const u64 left = data.words_cnt - all;
1295
1296 progress_noneed += left;
1297 }
1298 }
1299
1300 u64 progress_cur = all_restored + all_done + all_rejected;
1301 u64 progress_end = progress_total;
1302
1303 u64 progress_skip = 0;
1304
1305 if (data.skip)
1306 {
1307 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1308
1309 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1310 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1311 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1312 }
1313
1314 if (data.limit)
1315 {
1316 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1317
1318 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1319 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1320 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1321 }
1322
1323 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1324 u64 progress_end_relative_skip = progress_end - progress_skip;
1325
1326 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1327 {
1328 if (data.devices_status != STATUS_CRACKED)
1329 {
1330 #ifdef WIN
1331 __time64_t sec_etc = 0;
1332 #else
1333 time_t sec_etc = 0;
1334 #endif
1335
1336 if (hashes_all_ms)
1337 {
1338 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1339
1340 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1341
1342 sec_etc = ms_left / 1000;
1343 }
1344
1345 if (sec_etc == 0)
1346 {
1347 //log_info ("Time.Estimated.: 0 secs");
1348 }
1349 else if ((u64) sec_etc > ETC_MAX)
1350 {
1351 log_info ("Time.Estimated.: > 10 Years");
1352 }
1353 else
1354 {
1355 char display_etc[32] = { 0 };
1356
1357 struct tm tm_etc;
1358
1359 struct tm *tmp = NULL;
1360
1361 #ifdef WIN
1362
1363 tmp = _gmtime64 (&sec_etc);
1364
1365 #else
1366
1367 tmp = gmtime (&sec_etc);
1368
1369 #endif
1370
1371 if (tmp != NULL)
1372 {
1373 memset (&tm_etc, 0, sizeof (tm_etc));
1374
1375 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1376
1377 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1378
1379 time_t now;
1380
1381 time (&now);
1382
1383 now += sec_etc;
1384
1385 char *etc = ctime (&now);
1386
1387 size_t etc_len = strlen (etc);
1388
1389 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1390 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1391
1392 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1393 }
1394 }
1395 }
1396 }
1397
1398 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1399 {
1400 hc_device_param_t *device_param = &data.devices_param[device_id];
1401
1402 if (device_param->skipped) continue;
1403
1404 char display_dev_cur[16] = { 0 };
1405
1406 strncpy (display_dev_cur, "0.00", 4);
1407
1408 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1409
1410 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1411 }
1412
1413 char display_all_cur[16] = { 0 };
1414
1415 strncpy (display_all_cur, "0.00", 4);
1416
1417 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1418
1419 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1420
1421 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1422 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1423
1424 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);
1425
1426 // crack-per-time
1427
1428 if (data.digests_cnt > 100)
1429 {
1430 time_t now = time (NULL);
1431
1432 int cpt_cur_min = 0;
1433 int cpt_cur_hour = 0;
1434 int cpt_cur_day = 0;
1435
1436 for (int i = 0; i < CPT_BUF; i++)
1437 {
1438 const uint cracked = data.cpt_buf[i].cracked;
1439 const time_t timestamp = data.cpt_buf[i].timestamp;
1440
1441 if ((timestamp + 60) > now)
1442 {
1443 cpt_cur_min += cracked;
1444 }
1445
1446 if ((timestamp + 3600) > now)
1447 {
1448 cpt_cur_hour += cracked;
1449 }
1450
1451 if ((timestamp + 86400) > now)
1452 {
1453 cpt_cur_day += cracked;
1454 }
1455 }
1456
1457 double ms_real = ms_running - ms_paused;
1458
1459 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1460 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1461 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1462
1463 if ((data.cpt_start + 86400) < now)
1464 {
1465 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1466 cpt_cur_min,
1467 cpt_cur_hour,
1468 cpt_cur_day,
1469 cpt_avg_min,
1470 cpt_avg_hour,
1471 cpt_avg_day);
1472 }
1473 else if ((data.cpt_start + 3600) < now)
1474 {
1475 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1476 cpt_cur_min,
1477 cpt_cur_hour,
1478 cpt_avg_min,
1479 cpt_avg_hour,
1480 cpt_avg_day);
1481 }
1482 else if ((data.cpt_start + 60) < now)
1483 {
1484 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1485 cpt_cur_min,
1486 cpt_avg_min,
1487 cpt_avg_hour,
1488 cpt_avg_day);
1489 }
1490 else
1491 {
1492 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1493 cpt_avg_min,
1494 cpt_avg_hour,
1495 cpt_avg_day);
1496 }
1497 }
1498
1499 // Restore point
1500
1501 u64 restore_point = get_lowest_words_done ();
1502
1503 u64 restore_total = data.words_base;
1504
1505 float percent_restore = 0;
1506
1507 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1508
1509 if (progress_end_relative_skip)
1510 {
1511 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1512 {
1513 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1514 float percent_rejected = 0.0;
1515
1516 if (progress_cur)
1517 {
1518 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1519 }
1520
1521 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);
1522 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1523
1524 if (data.restore_disable == 0)
1525 {
1526 if (percent_finished != 1)
1527 {
1528 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1529 }
1530 }
1531 }
1532 }
1533 else
1534 {
1535 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1536 {
1537 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1538 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1539
1540 if (data.restore_disable == 0)
1541 {
1542 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1543 }
1544 }
1545 else
1546 {
1547 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1548 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1549
1550 // --restore not allowed if stdin is used -- really? why?
1551
1552 //if (data.restore_disable == 0)
1553 //{
1554 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1555 //}
1556 }
1557 }
1558
1559 #ifdef HAVE_HWMON
1560 if (data.gpu_temp_disable == 0)
1561 {
1562 hc_thread_mutex_lock (mux_adl);
1563
1564 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1565 {
1566 hc_device_param_t *device_param = &data.devices_param[device_id];
1567
1568 if (device_param->skipped) continue;
1569
1570 #define HM_STR_BUF_SIZE 255
1571
1572 if (data.hm_device[device_id].fan_supported == 1)
1573 {
1574 char utilization[HM_STR_BUF_SIZE] = { 0 };
1575 char temperature[HM_STR_BUF_SIZE] = { 0 };
1576 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1577
1578 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1579 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1580
1581 if (device_param->vendor_id == VENDOR_ID_AMD)
1582 {
1583 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1584 }
1585 else if (device_param->vendor_id == VENDOR_ID_NV)
1586 {
1587 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1588 }
1589
1590 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1591 }
1592 else
1593 {
1594 char utilization[HM_STR_BUF_SIZE] = { 0 };
1595 char temperature[HM_STR_BUF_SIZE] = { 0 };
1596
1597 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1598 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1599
1600 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1601 }
1602 }
1603
1604 hc_thread_mutex_unlock (mux_adl);
1605 }
1606 #endif // HAVE_HWMON
1607 }
1608
1609 static void status_benchmark ()
1610 {
1611 if (data.devices_status == STATUS_INIT) return;
1612 if (data.devices_status == STATUS_STARTING) return;
1613
1614 if (data.words_cnt == 0) return;
1615
1616 u64 speed_cnt[DEVICES_MAX] = { 0 };
1617 double speed_ms[DEVICES_MAX] = { 0 };
1618
1619 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1620 {
1621 hc_device_param_t *device_param = &data.devices_param[device_id];
1622
1623 if (device_param->skipped) continue;
1624
1625 speed_cnt[device_id] = device_param->speed_cnt[0];
1626 speed_ms[device_id] = device_param->speed_ms[0];
1627 }
1628
1629 float hashes_all_ms = 0;
1630
1631 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1632
1633 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1634 {
1635 hc_device_param_t *device_param = &data.devices_param[device_id];
1636
1637 if (device_param->skipped) continue;
1638
1639 hashes_dev_ms[device_id] = 0;
1640
1641 if (speed_ms[device_id])
1642 {
1643 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1644
1645 hashes_all_ms += hashes_dev_ms[device_id];
1646 }
1647 }
1648
1649 /**
1650 * exec time
1651 */
1652
1653 double exec_all_ms[DEVICES_MAX] = { 0 };
1654
1655 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1656 {
1657 hc_device_param_t *device_param = &data.devices_param[device_id];
1658
1659 if (device_param->skipped) continue;
1660
1661 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1662
1663 exec_all_ms[device_id] = exec_ms_avg;
1664 }
1665
1666 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1667 {
1668 hc_device_param_t *device_param = &data.devices_param[device_id];
1669
1670 if (device_param->skipped) continue;
1671
1672 char display_dev_cur[16] = { 0 };
1673
1674 strncpy (display_dev_cur, "0.00", 4);
1675
1676 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1677
1678 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1679 }
1680
1681 char display_all_cur[16] = { 0 };
1682
1683 strncpy (display_all_cur, "0.00", 4);
1684
1685 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1686
1687 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1688 }
1689
1690 /**
1691 * hashcat -only- functions
1692 */
1693
1694 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1695 {
1696 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1697 {
1698 if (attack_kern == ATTACK_KERN_STRAIGHT)
1699 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1700 else if (attack_kern == ATTACK_KERN_COMBI)
1701 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1702 else if (attack_kern == ATTACK_KERN_BF)
1703 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1704 }
1705 else
1706 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1707 }
1708
1709 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)
1710 {
1711 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1712 {
1713 if (attack_kern == ATTACK_KERN_STRAIGHT)
1714 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1715 else if (attack_kern == ATTACK_KERN_COMBI)
1716 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1717 else if (attack_kern == ATTACK_KERN_BF)
1718 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1719 }
1720 else
1721 {
1722 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1723 }
1724 }
1725
1726 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1727 {
1728 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1729 {
1730 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1731 }
1732 else
1733 {
1734 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1735 }
1736 }
1737
1738 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)
1739 {
1740 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1741 {
1742 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1743 }
1744 else
1745 {
1746 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1747 }
1748 }
1749
1750 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1751 {
1752 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1753 }
1754
1755 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1756 {
1757 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1758 }
1759
1760 static uint convert_from_hex (char *line_buf, const uint line_len)
1761 {
1762 if (line_len & 1) return (line_len); // not in hex
1763
1764 if (data.hex_wordlist == 1)
1765 {
1766 uint i;
1767 uint j;
1768
1769 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1770 {
1771 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1772 }
1773
1774 memset (line_buf + i, 0, line_len - i);
1775
1776 return (i);
1777 }
1778 else if (line_len >= 6) // $HEX[] = 6
1779 {
1780 if (line_buf[0] != '$') return (line_len);
1781 if (line_buf[1] != 'H') return (line_len);
1782 if (line_buf[2] != 'E') return (line_len);
1783 if (line_buf[3] != 'X') return (line_len);
1784 if (line_buf[4] != '[') return (line_len);
1785 if (line_buf[line_len - 1] != ']') return (line_len);
1786
1787 uint i;
1788 uint j;
1789
1790 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1791 {
1792 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1793 }
1794
1795 memset (line_buf + i, 0, line_len - i);
1796
1797 return (i);
1798 }
1799
1800 return (line_len);
1801 }
1802
1803 static void clear_prompt ()
1804 {
1805 fputc ('\r', stdout);
1806
1807 for (size_t i = 0; i < strlen (PROMPT); i++)
1808 {
1809 fputc (' ', stdout);
1810 }
1811
1812 fputc ('\r', stdout);
1813
1814 fflush (stdout);
1815 }
1816
1817 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1818 {
1819 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);
1820 }
1821
1822 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1823 {
1824 char *outfile = data.outfile;
1825 uint quiet = data.quiet;
1826 FILE *pot_fp = data.pot_fp;
1827 uint loopback = data.loopback;
1828 uint debug_mode = data.debug_mode;
1829 char *debug_file = data.debug_file;
1830
1831 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1832 int debug_rule_len = 0; // -1 error
1833 uint debug_plain_len = 0;
1834
1835 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1836
1837 // hash
1838
1839 char out_buf[HCBUFSIZ] = { 0 };
1840
1841 ascii_digest (out_buf, salt_pos, digest_pos);
1842
1843 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1844
1845 // plain
1846
1847 plain_t plain;
1848
1849 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);
1850
1851 uint gidvid = plain.gidvid;
1852 uint il_pos = plain.il_pos;
1853
1854 u64 crackpos = device_param->words_off;
1855
1856 uint plain_buf[16] = { 0 };
1857
1858 u8 *plain_ptr = (u8 *) plain_buf;
1859 unsigned int plain_len = 0;
1860
1861 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1862 {
1863 u64 gidd = gidvid;
1864 u64 gidm = 0;
1865
1866 pw_t pw;
1867
1868 gidd_to_pw_t (device_param, gidd, &pw);
1869
1870 for (int i = 0, j = gidm; i < 16; i++, j++)
1871 {
1872 plain_buf[i] = pw.i[j];
1873 }
1874
1875 plain_len = pw.pw_len;
1876
1877 const uint off = device_param->innerloop_pos + il_pos;
1878
1879 if (debug_mode > 0)
1880 {
1881 debug_rule_len = 0;
1882
1883 // save rule
1884 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1885 {
1886 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1887
1888 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1889 }
1890
1891 // save plain
1892 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1893 {
1894 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1895
1896 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1897
1898 debug_plain_len = plain_len;
1899 }
1900 }
1901
1902 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1903
1904 crackpos += gidvid;
1905 crackpos *= data.kernel_rules_cnt;
1906 crackpos += device_param->innerloop_pos + il_pos;
1907
1908 if (plain_len > data.pw_max) plain_len = data.pw_max;
1909 }
1910 else if (data.attack_mode == ATTACK_MODE_COMBI)
1911 {
1912 u64 gidd = gidvid;
1913 u64 gidm = 0;
1914
1915 pw_t pw;
1916
1917 gidd_to_pw_t (device_param, gidd, &pw);
1918
1919 for (int i = 0, j = gidm; i < 16; i++, j++)
1920 {
1921 plain_buf[i] = pw.i[j];
1922 }
1923
1924 plain_len = pw.pw_len;
1925
1926 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1927 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1928
1929 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1930 {
1931 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1932 }
1933 else
1934 {
1935 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1936
1937 memcpy (plain_ptr, comb_buf, comb_len);
1938 }
1939
1940 plain_len += comb_len;
1941
1942 crackpos += gidvid;
1943 crackpos *= data.combs_cnt;
1944 crackpos += device_param->innerloop_pos + il_pos;
1945
1946 if (data.pw_max != PW_DICTMAX1)
1947 {
1948 if (plain_len > data.pw_max) plain_len = data.pw_max;
1949 }
1950 }
1951 else if (data.attack_mode == ATTACK_MODE_BF)
1952 {
1953 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1954 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1955
1956 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1957 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1958
1959 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1960 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1961
1962 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1963 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1964
1965 plain_len = data.css_cnt;
1966
1967 crackpos += gidvid;
1968 crackpos *= data.bfs_cnt;
1969 crackpos += device_param->innerloop_pos + il_pos;
1970 }
1971 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1972 {
1973 u64 gidd = gidvid;
1974 u64 gidm = 0;
1975
1976 pw_t pw;
1977
1978 gidd_to_pw_t (device_param, gidd, &pw);
1979
1980 for (int i = 0, j = gidm; i < 16; i++, j++)
1981 {
1982 plain_buf[i] = pw.i[j];
1983 }
1984
1985 plain_len = pw.pw_len;
1986
1987 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
1988
1989 uint start = 0;
1990 uint stop = device_param->kernel_params_mp_buf32[4];
1991
1992 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
1993
1994 plain_len += start + stop;
1995
1996 crackpos += gidvid;
1997 crackpos *= data.combs_cnt;
1998 crackpos += device_param->innerloop_pos + il_pos;
1999
2000 if (data.pw_max != PW_DICTMAX1)
2001 {
2002 if (plain_len > data.pw_max) plain_len = data.pw_max;
2003 }
2004 }
2005 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2006 {
2007 u64 gidd = gidvid;
2008 u64 gidm = 0;
2009
2010 pw_t pw;
2011
2012 gidd_to_pw_t (device_param, gidd, &pw);
2013
2014 for (int i = 0, j = gidm; i < 16; i++, j++)
2015 {
2016 plain_buf[i] = pw.i[j];
2017 }
2018
2019 plain_len = pw.pw_len;
2020
2021 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2022
2023 uint start = 0;
2024 uint stop = device_param->kernel_params_mp_buf32[4];
2025
2026 memmove (plain_ptr + stop, plain_ptr, plain_len);
2027
2028 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2029
2030 plain_len += start + stop;
2031
2032 crackpos += gidvid;
2033 crackpos *= data.combs_cnt;
2034 crackpos += device_param->innerloop_pos + il_pos;
2035
2036 if (data.pw_max != PW_DICTMAX1)
2037 {
2038 if (plain_len > data.pw_max) plain_len = data.pw_max;
2039 }
2040 }
2041
2042 if (data.attack_mode == ATTACK_MODE_BF)
2043 {
2044 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2045 {
2046 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2047 {
2048 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2049 {
2050 plain_len = plain_len - data.salts_buf[0].salt_len;
2051 }
2052 }
2053
2054 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2055 {
2056 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2057 {
2058 plain_ptr[j] = plain_ptr[i];
2059 }
2060
2061 plain_len = plain_len / 2;
2062 }
2063 }
2064 }
2065
2066 // if enabled, update also the potfile
2067
2068 if (pot_fp)
2069 {
2070 lock_file (pot_fp);
2071
2072 fprintf (pot_fp, "%s:", out_buf);
2073
2074 format_plain (pot_fp, plain_ptr, plain_len, 1);
2075
2076 fputc ('\n', pot_fp);
2077
2078 fflush (pot_fp);
2079
2080 unlock_file (pot_fp);
2081 }
2082
2083 // outfile
2084
2085 FILE *out_fp = NULL;
2086
2087 if (outfile != NULL)
2088 {
2089 if ((out_fp = fopen (outfile, "ab")) == NULL)
2090 {
2091 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2092
2093 out_fp = stdout;
2094 }
2095 lock_file (out_fp);
2096 }
2097 else
2098 {
2099 out_fp = stdout;
2100
2101 if (quiet == 0) clear_prompt ();
2102 }
2103
2104 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2105
2106 if (outfile != NULL)
2107 {
2108 if (out_fp != stdout)
2109 {
2110 fclose (out_fp);
2111 }
2112 }
2113 else
2114 {
2115 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2116 {
2117 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2118 {
2119 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2120 if (quiet == 0) fflush (stdout);
2121 }
2122 }
2123 }
2124
2125 // loopback
2126
2127 if (loopback)
2128 {
2129 char *loopback_file = data.loopback_file;
2130
2131 FILE *fb_fp = NULL;
2132
2133 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2134 {
2135 lock_file (fb_fp);
2136
2137 format_plain (fb_fp, plain_ptr, plain_len, 1);
2138
2139 fputc ('\n', fb_fp);
2140
2141 fclose (fb_fp);
2142 }
2143 }
2144
2145 // (rule) debug mode
2146
2147 // the next check implies that:
2148 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2149 // - debug_mode > 0
2150
2151 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2152 {
2153 if (debug_rule_len < 0) debug_rule_len = 0;
2154
2155 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2156
2157 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2158
2159 if ((quiet == 0) && (debug_file == NULL))
2160 {
2161 fprintf (stdout, "%s", PROMPT);
2162 fflush (stdout);
2163 }
2164 }
2165 }
2166
2167 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2168 {
2169 salt_t *salt_buf = &data.salts_buf[salt_pos];
2170
2171 int found = 0;
2172
2173 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);
2174
2175 for (uint i = 0; i < device_param->kernel_threads; i++) if (device_param->result[i] == 1) found = 1;
2176
2177 if (found == 1)
2178 {
2179 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2180
2181 log_info_nn ("");
2182
2183 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);
2184
2185 uint cpt_cracked = 0;
2186
2187 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2188 {
2189 uint idx = salt_buf->digests_offset + digest_pos;
2190
2191 if (data.digests_shown_tmp[idx] == 0) continue;
2192
2193 if (data.digests_shown[idx] == 1) continue;
2194
2195 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2196 {
2197 data.digests_shown[idx] = 1;
2198
2199 data.digests_done++;
2200
2201 cpt_cracked++;
2202
2203 salt_buf->digests_done++;
2204
2205 if (salt_buf->digests_done == salt_buf->digests_cnt)
2206 {
2207 data.salts_shown[salt_pos] = 1;
2208
2209 data.salts_done++;
2210 }
2211 }
2212
2213 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2214
2215 check_hash (device_param, salt_pos, digest_pos);
2216 }
2217
2218 if (cpt_cracked > 0)
2219 {
2220 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2221 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2222
2223 data.cpt_pos++;
2224
2225 data.cpt_total += cpt_cracked;
2226
2227 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2228 }
2229
2230 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2231 {
2232 // we need to reset cracked state on the device
2233 // otherwise host thinks again and again the hash was cracked
2234 // and returns invalid password each time
2235
2236 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2237
2238 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);
2239 }
2240
2241 memset (device_param->result, 0, device_param->size_results);
2242
2243 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);
2244 }
2245 }
2246
2247 static void save_hash ()
2248 {
2249 char *hashfile = data.hashfile;
2250
2251 char new_hashfile[256] = { 0 };
2252 char old_hashfile[256] = { 0 };
2253
2254 snprintf (new_hashfile, 255, "%s.new", hashfile);
2255 snprintf (old_hashfile, 255, "%s.old", hashfile);
2256
2257 unlink (new_hashfile);
2258
2259 char separator = data.separator;
2260
2261 FILE *fp = fopen (new_hashfile, "wb");
2262
2263 if (fp == NULL)
2264 {
2265 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2266
2267 exit (-1);
2268 }
2269
2270 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2271 {
2272 if (data.salts_shown[salt_pos] == 1) continue;
2273
2274 salt_t *salt_buf = &data.salts_buf[salt_pos];
2275
2276 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2277 {
2278 uint idx = salt_buf->digests_offset + digest_pos;
2279
2280 if (data.digests_shown[idx] == 1) continue;
2281
2282 if (data.hash_mode != 2500)
2283 {
2284 char out_buf[HCBUFSIZ] = { 0 };
2285
2286 if (data.username == 1)
2287 {
2288 user_t *user = data.hash_info[idx]->user;
2289
2290 uint i;
2291
2292 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2293
2294 fputc (separator, fp);
2295 }
2296
2297 ascii_digest (out_buf, salt_pos, digest_pos);
2298
2299 fputs (out_buf, fp);
2300
2301 log_out (fp, "");
2302 }
2303 else
2304 {
2305 hccap_t hccap;
2306
2307 to_hccap_t (&hccap, salt_pos, digest_pos);
2308
2309 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2310 }
2311 }
2312 }
2313
2314 fflush (fp);
2315
2316 fclose (fp);
2317
2318 unlink (old_hashfile);
2319
2320 if (rename (hashfile, old_hashfile) != 0)
2321 {
2322 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2323
2324 exit (-1);
2325 }
2326
2327 unlink (hashfile);
2328
2329 if (rename (new_hashfile, hashfile) != 0)
2330 {
2331 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2332
2333 exit (-1);
2334 }
2335
2336 unlink (old_hashfile);
2337 }
2338
2339 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2340 {
2341 // function called only in case kernel_power_all > words_left
2342
2343 float kernel_power_div = (float) (total_left) / kernel_power_all;
2344
2345 kernel_power_div += kernel_power_div / 100;
2346
2347 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2348
2349 while (kernel_power_new < total_left)
2350 {
2351 kernel_power_div += kernel_power_div / 100;
2352
2353 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2354 }
2355
2356 if (data.quiet == 0)
2357 {
2358 clear_prompt ();
2359
2360 log_info ("");
2361
2362 log_info ("INFO: approaching final keyspace, workload adjusted");
2363
2364 log_info ("");
2365
2366 fprintf (stdout, "%s", PROMPT);
2367
2368 fflush (stdout);
2369 }
2370
2371 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2372
2373 return kernel_power_div;
2374 }
2375
2376 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2377 {
2378 uint num_elements = num;
2379
2380 device_param->kernel_params_buf32[30] = data.combs_mode;
2381 device_param->kernel_params_buf32[31] = num;
2382
2383 uint kernel_threads = device_param->kernel_threads;
2384
2385 while (num_elements % kernel_threads) num_elements++;
2386
2387 cl_kernel kernel = NULL;
2388
2389 switch (kern_run)
2390 {
2391 case KERN_RUN_1: kernel = device_param->kernel1; break;
2392 case KERN_RUN_12: kernel = device_param->kernel12; break;
2393 case KERN_RUN_2: kernel = device_param->kernel2; break;
2394 case KERN_RUN_23: kernel = device_param->kernel23; break;
2395 case KERN_RUN_3: kernel = device_param->kernel3; break;
2396 }
2397
2398 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2399 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2400 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2401 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2402 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2403 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2404 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2405 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2406 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2407 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2408 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2409
2410 hc_timer_t timer;
2411
2412 hc_timer_set (&timer);
2413
2414 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2415 {
2416 const size_t global_work_size[3] = { num_elements, 32, 1 };
2417 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2418
2419 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2420 }
2421 else
2422 {
2423 size_t workgroup_size = 0;
2424
2425 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2426
2427 if (kern_run == KERN_RUN_2)
2428 {
2429 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2430 {
2431 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2432 }
2433 }
2434
2435 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2436
2437 while (num_elements % kernel_threads) num_elements++;
2438
2439 const size_t global_work_size[3] = { num_elements, 1, 1 };
2440 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2441
2442 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2443 }
2444
2445 hc_clFlush (data.ocl, device_param->command_queue);
2446
2447 hc_clFinish (data.ocl, device_param->command_queue);
2448
2449 if (event_update)
2450 {
2451 double exec_time;
2452
2453 hc_timer_get (timer, exec_time);
2454
2455 uint exec_pos = device_param->exec_pos;
2456
2457 device_param->exec_ms[exec_pos] = exec_time;
2458
2459 exec_pos++;
2460
2461 if (exec_pos == EXEC_CACHE)
2462 {
2463 exec_pos = 0;
2464 }
2465
2466 device_param->exec_pos = exec_pos;
2467 }
2468 }
2469
2470 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2471 {
2472 uint num_elements = num;
2473
2474 switch (kern_run)
2475 {
2476 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2477 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2478 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2479 }
2480
2481 // causes problems with special threads like in bcrypt
2482 // const uint kernel_threads = device_param->kernel_threads;
2483
2484 uint kernel_threads = device_param->kernel_threads;
2485
2486 while (num_elements % kernel_threads) num_elements++;
2487
2488 cl_kernel kernel = NULL;
2489
2490 switch (kern_run)
2491 {
2492 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2493 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2494 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2495 }
2496
2497 switch (kern_run)
2498 {
2499 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2500 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2501 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2502 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2503 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2504 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2505 break;
2506 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2507 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2508 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2509 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2510 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2511 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2512 break;
2513 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2514 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2515 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2516 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2517 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2518 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2519 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2520 break;
2521 }
2522
2523 size_t workgroup_size = 0;
2524
2525 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), &workgroup_size, NULL);
2526
2527 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2528
2529 const size_t global_work_size[3] = { num_elements, 1, 1 };
2530 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2531
2532 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2533
2534 hc_clFlush (data.ocl, device_param->command_queue);
2535
2536 hc_clFinish (data.ocl, device_param->command_queue);
2537 }
2538
2539 static void run_kernel_tm (hc_device_param_t *device_param)
2540 {
2541 const uint num_elements = 1024; // fixed
2542
2543 uint kernel_threads = 32;
2544
2545 cl_kernel kernel = device_param->kernel_tm;
2546
2547 size_t workgroup_size = 0;
2548
2549 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2550
2551 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2552
2553 const size_t global_work_size[3] = { num_elements, 1, 1 };
2554 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2555
2556 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2557
2558 hc_clFlush (data.ocl, device_param->command_queue);
2559
2560 hc_clFinish (data.ocl, device_param->command_queue);
2561 }
2562
2563 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2564 {
2565 uint num_elements = num;
2566
2567 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2568 device_param->kernel_params_amp_buf32[6] = num_elements;
2569
2570 // causes problems with special threads like in bcrypt
2571 // const uint kernel_threads = device_param->kernel_threads;
2572
2573 uint kernel_threads = device_param->kernel_threads;
2574
2575 while (num_elements % kernel_threads) num_elements++;
2576
2577 cl_kernel kernel = device_param->kernel_amp;
2578
2579 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2580 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2581
2582 size_t workgroup_size = 0;
2583
2584 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2585
2586 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2587
2588 const size_t global_work_size[3] = { num_elements, 1, 1 };
2589 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2590
2591 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2592
2593 hc_clFlush (data.ocl, device_param->command_queue);
2594
2595 hc_clFinish (data.ocl, device_param->command_queue);
2596 }
2597
2598 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2599 {
2600 int rc = -1;
2601
2602 if (device_param->opencl_v12 && device_param->vendor_id == VENDOR_ID_AMD)
2603 {
2604 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2605
2606 const cl_uchar zero = 0;
2607
2608 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2609 }
2610
2611 if (rc != 0)
2612 {
2613 // NOTE: clEnqueueFillBuffer () always fails with -59
2614 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2615 // How's that possible, OpenCL 1.2 support is advertised??
2616 // We need to workaround...
2617
2618 #define FILLSZ 0x100000
2619
2620 char *tmp = (char *) mymalloc (FILLSZ);
2621
2622 for (size_t i = 0; i < size; i += FILLSZ)
2623 {
2624 const size_t left = size - i;
2625
2626 const size_t fillsz = MIN (FILLSZ, left);
2627
2628 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2629 }
2630
2631 myfree (tmp);
2632 }
2633 }
2634
2635 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)
2636 {
2637 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2638 {
2639 if (attack_mode == ATTACK_MODE_BF)
2640 {
2641 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2642 {
2643 const uint size_tm = 32 * sizeof (bs_word_t);
2644
2645 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2646
2647 run_kernel_tm (device_param);
2648
2649 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);
2650 }
2651 }
2652
2653 if (highest_pw_len < 16)
2654 {
2655 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2656 }
2657 else if (highest_pw_len < 32)
2658 {
2659 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2660 }
2661 else
2662 {
2663 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2664 }
2665 }
2666 else
2667 {
2668 run_kernel_amp (device_param, pws_cnt);
2669
2670 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2671
2672 if (opts_type & OPTS_TYPE_HOOK12)
2673 {
2674 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2675 }
2676
2677 uint iter = salt_buf->salt_iter;
2678
2679 uint loop_step = device_param->kernel_loops;
2680
2681 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2682 {
2683 uint loop_left = iter - loop_pos;
2684
2685 loop_left = MIN (loop_left, loop_step);
2686
2687 device_param->kernel_params_buf32[25] = loop_pos;
2688 device_param->kernel_params_buf32[26] = loop_left;
2689
2690 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2691
2692 if (data.devices_status == STATUS_CRACKED) break;
2693 if (data.devices_status == STATUS_ABORTED) break;
2694 if (data.devices_status == STATUS_QUIT) break;
2695
2696 /**
2697 * speed
2698 */
2699
2700 const float iter_part = (float) (loop_pos + loop_left) / iter;
2701
2702 const u64 perf_sum_all = pws_cnt * iter_part;
2703
2704 double speed_ms;
2705
2706 hc_timer_get (device_param->timer_speed, speed_ms);
2707
2708 const u32 speed_pos = device_param->speed_pos;
2709
2710 device_param->speed_cnt[speed_pos] = perf_sum_all;
2711
2712 device_param->speed_ms[speed_pos] = speed_ms;
2713
2714 if (data.benchmark == 1)
2715 {
2716 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
2717 }
2718 }
2719
2720 if (opts_type & OPTS_TYPE_HOOK23)
2721 {
2722 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2723
2724 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);
2725
2726 // do something with data
2727
2728 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);
2729 }
2730
2731 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2732 }
2733 }
2734
2735 static int run_rule_engine (const int rule_len, const char *rule_buf)
2736 {
2737 if (rule_len == 0)
2738 {
2739 return 0;
2740 }
2741 else if (rule_len == 1)
2742 {
2743 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2744 }
2745
2746 return 1;
2747 }
2748
2749 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2750 {
2751 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2752 {
2753 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);
2754 }
2755 else if (data.attack_kern == ATTACK_KERN_COMBI)
2756 {
2757 if (data.attack_mode == ATTACK_MODE_HYBRID2)
2758 {
2759 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2760 {
2761 for (u32 i = 0; i < pws_cnt; i++)
2762 {
2763 const u32 pw_len = device_param->pws_buf[i].pw_len;
2764
2765 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2766
2767 ptr[pw_len] = 0x01;
2768 }
2769 }
2770 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2771 {
2772 for (u32 i = 0; i < pws_cnt; i++)
2773 {
2774 const u32 pw_len = device_param->pws_buf[i].pw_len;
2775
2776 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2777
2778 ptr[pw_len] = 0x80;
2779 }
2780 }
2781 }
2782
2783 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);
2784 }
2785 else if (data.attack_kern == ATTACK_KERN_BF)
2786 {
2787 const u64 off = device_param->words_off;
2788
2789 device_param->kernel_params_mp_l_buf64[3] = off;
2790
2791 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2792 }
2793 }
2794
2795 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
2796 {
2797 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2798
2799 device_param->kernel_params_buf32[25] = 0;
2800 device_param->kernel_params_buf32[26] = kernel_loops; // not a bug, both need to be set
2801 device_param->kernel_params_buf32[27] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
2802
2803 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2804 {
2805 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2806 }
2807 else
2808 {
2809 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2810 }
2811
2812 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
2813
2814 return exec_ms_prev;
2815 }
2816
2817 static void autotune (hc_device_param_t *device_param)
2818 {
2819 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2820
2821 const u32 kernel_accel_min = device_param->kernel_accel_min;
2822 const u32 kernel_accel_max = device_param->kernel_accel_max;
2823
2824 const u32 kernel_loops_min = device_param->kernel_loops_min;
2825 const u32 kernel_loops_max = device_param->kernel_loops_max;
2826
2827 u32 kernel_accel = kernel_accel_min;
2828 u32 kernel_loops = kernel_loops_min;
2829
2830 // init some fake words
2831
2832 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
2833
2834 for (u32 i = 0; i < kernel_power_max; i++)
2835 {
2836 device_param->pws_buf[i].i[0] = i;
2837 device_param->pws_buf[i].i[1] = 0x01234567;
2838 device_param->pws_buf[i].pw_len = 7;
2839 }
2840
2841 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, kernel_power_max * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2842
2843 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2844 {
2845 run_kernel_amp (device_param, kernel_power_max);
2846 }
2847
2848 // begin actual testing
2849
2850 double exec_ms_final = try_run (device_param, kernel_accel, kernel_loops);
2851
2852 if ((kernel_loops_min == kernel_loops_max) || (kernel_accel_min == kernel_accel_max))
2853 {
2854 // we do this in case the user specified a fixed -u and -n on the commandline
2855 // so we have a cached kernel for benchmark
2856
2857 try_run (device_param, kernel_accel, kernel_loops);
2858 try_run (device_param, kernel_accel, kernel_loops);
2859 try_run (device_param, kernel_accel, kernel_loops);
2860 try_run (device_param, kernel_accel, kernel_loops);
2861 try_run (device_param, kernel_accel, kernel_loops);
2862 }
2863
2864 // first find out highest kernel-loops that stays below target_ms
2865
2866 #define STEPS_CNT 10
2867
2868 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
2869 {
2870 double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
2871
2872 if (exec_ms < target_ms) break;
2873 }
2874
2875 // now the same for kernel-accel but with the new kernel-loops from previous loop set
2876
2877 if (kernel_accel_min < kernel_accel_max)
2878 {
2879 for (int i = 0; i < STEPS_CNT; i++)
2880 {
2881 const u32 kernel_accel_try = 1 << i;
2882
2883 if (kernel_accel_try < kernel_accel_min) continue;
2884 if (kernel_accel_try > kernel_accel_max) break;
2885
2886 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
2887
2888 if (exec_ms > target_ms) break;
2889
2890 exec_ms_final = exec_ms;
2891
2892 kernel_accel = kernel_accel_try;
2893 }
2894 }
2895
2896 // there's a chance that we have a fixed kernel_loops but not a fixed kernel_accel
2897 // in such a case the above function would not create any change
2898 // we'll use the runtime to find out if we're allow to do last improvement
2899
2900 if (exec_ms_final > 0)
2901 {
2902 if ((exec_ms_final * 2) <= target_ms)
2903 {
2904 const double exec_left = target_ms / exec_ms_final;
2905
2906 const double accel_left = kernel_accel_max / kernel_accel;
2907
2908 const int exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
2909
2910 if (exec_accel_min >= 2)
2911 {
2912 kernel_accel *= exec_accel_min;
2913 }
2914 }
2915 }
2916
2917 // balancing the workload turns out to be very efficient
2918
2919 const u32 kernel_power_balance = kernel_accel * kernel_loops;
2920
2921 u32 sqrtv;
2922
2923 for (sqrtv = 1; sqrtv < 0x100000; sqrtv++)
2924 {
2925 if ((sqrtv * sqrtv) >= kernel_power_balance) break;
2926 }
2927
2928 const u32 kernel_accel_try = sqrtv;
2929 const u32 kernel_loops_try = sqrtv;
2930
2931 if ((kernel_accel_try <= kernel_accel_max) && (kernel_loops_try >= kernel_loops_min))
2932 {
2933 kernel_accel = kernel_accel_try;
2934 kernel_loops = kernel_loops_try;
2935 }
2936
2937 // reset fake words
2938
2939 memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
2940
2941 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, kernel_power_max * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2942 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_amp_buf, CL_TRUE, 0, kernel_power_max * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2943
2944 // reset timer
2945
2946 device_param->exec_pos = 0;
2947
2948 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
2949
2950 // store
2951
2952 device_param->kernel_accel = kernel_accel;
2953 device_param->kernel_loops = kernel_loops;
2954
2955 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
2956
2957 device_param->kernel_power = kernel_power;
2958
2959 #ifdef DEBUG
2960
2961 if (data.quiet == 0)
2962 {
2963 clear_prompt ();
2964
2965 log_info ("Device #%u: autotuned kernel-accel to %u\n"
2966 "Device #%u: autotuned kernel-loops to %u\n",
2967 device_param->device_id + 1, kernel_accel,
2968 device_param->device_id + 1, kernel_loops);
2969
2970 fprintf (stdout, "%s", PROMPT);
2971
2972 fflush (stdout);
2973 }
2974
2975 #endif
2976 }
2977
2978 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
2979 {
2980 char *line_buf = (char *) mymalloc (HCBUFSIZ);
2981
2982 // init speed timer
2983
2984 uint speed_pos = device_param->speed_pos;
2985
2986 #ifdef _POSIX
2987 if (device_param->timer_speed.tv_sec == 0)
2988 {
2989 hc_timer_set (&device_param->timer_speed);
2990 }
2991 #endif
2992
2993 #ifdef _WIN
2994 if (device_param->timer_speed.QuadPart == 0)
2995 {
2996 hc_timer_set (&device_param->timer_speed);
2997 }
2998 #endif
2999
3000 // find higest password length, this is for optimization stuff
3001
3002 uint highest_pw_len = 0;
3003
3004 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3005 {
3006 }
3007 else if (data.attack_kern == ATTACK_KERN_COMBI)
3008 {
3009 }
3010 else if (data.attack_kern == ATTACK_KERN_BF)
3011 {
3012 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3013 + device_param->kernel_params_mp_l_buf32[5];
3014 }
3015
3016 // iteration type
3017
3018 uint innerloop_step = 0;
3019 uint innerloop_cnt = 0;
3020
3021 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3022 else innerloop_step = 1;
3023
3024 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3025 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3026 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3027
3028 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3029
3030 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3031 {
3032 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3033
3034 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3035
3036 if (data.devices_status == STATUS_CRACKED) break;
3037 if (data.devices_status == STATUS_ABORTED) break;
3038 if (data.devices_status == STATUS_QUIT) break;
3039 if (data.devices_status == STATUS_BYPASS) break;
3040
3041 salt_t *salt_buf = &data.salts_buf[salt_pos];
3042
3043 device_param->kernel_params_buf32[24] = salt_pos;
3044 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3045 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3046
3047 FILE *combs_fp = device_param->combs_fp;
3048
3049 if (data.attack_mode == ATTACK_MODE_COMBI)
3050 {
3051 rewind (combs_fp);
3052 }
3053
3054 // innerloops
3055
3056 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3057 {
3058 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3059
3060 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3061
3062 if (data.devices_status == STATUS_CRACKED) break;
3063 if (data.devices_status == STATUS_ABORTED) break;
3064 if (data.devices_status == STATUS_QUIT) break;
3065 if (data.devices_status == STATUS_BYPASS) break;
3066
3067 uint innerloop_left = innerloop_cnt - innerloop_pos;
3068
3069 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3070
3071 device_param->innerloop_pos = innerloop_pos;
3072 device_param->innerloop_left = innerloop_left;
3073
3074 device_param->kernel_params_buf32[27] = innerloop_left;
3075
3076 // i think we can get rid of this
3077 if (innerloop_left == 0)
3078 {
3079 puts ("bug, how should this happen????\n");
3080
3081 continue;
3082 }
3083
3084 if (data.salts_shown[salt_pos] == 1)
3085 {
3086 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3087
3088 continue;
3089 }
3090
3091 // initialize amplifiers
3092
3093 if (data.attack_mode == ATTACK_MODE_COMBI)
3094 {
3095 uint i = 0;
3096
3097 while (i < innerloop_left)
3098 {
3099 if (feof (combs_fp)) break;
3100
3101 int line_len = fgetl (combs_fp, line_buf);
3102
3103 if (line_len >= PW_MAX1) continue;
3104
3105 line_len = convert_from_hex (line_buf, line_len);
3106
3107 char *line_buf_new = line_buf;
3108
3109 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3110 {
3111 char rule_buf_out[BLOCK_SIZE] = { 0 };
3112
3113 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3114
3115 if (rule_len_out < 0)
3116 {
3117 data.words_progress_rejected[salt_pos] += pws_cnt;
3118
3119 continue;
3120 }
3121
3122 line_len = rule_len_out;
3123
3124 line_buf_new = rule_buf_out;
3125 }
3126
3127 line_len = MIN (line_len, PW_DICTMAX);
3128
3129 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3130
3131 memcpy (ptr, line_buf_new, line_len);
3132
3133 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3134
3135 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3136 {
3137 uppercase (ptr, line_len);
3138 }
3139
3140 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3141 {
3142 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3143 {
3144 ptr[line_len] = 0x80;
3145 }
3146
3147 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3148 {
3149 ptr[line_len] = 0x01;
3150 }
3151 }
3152
3153 device_param->combs_buf[i].pw_len = line_len;
3154
3155 i++;
3156 }
3157
3158 for (uint j = i; j < innerloop_left; j++)
3159 {
3160 device_param->combs_buf[j].i[0] = 0;
3161 device_param->combs_buf[j].i[1] = 0;
3162 device_param->combs_buf[j].i[2] = 0;
3163 device_param->combs_buf[j].i[3] = 0;
3164 device_param->combs_buf[j].i[4] = 0;
3165 device_param->combs_buf[j].i[5] = 0;
3166 device_param->combs_buf[j].i[6] = 0;
3167 device_param->combs_buf[j].i[7] = 0;
3168
3169 device_param->combs_buf[j].pw_len = 0;
3170 }
3171
3172 innerloop_left = i;
3173 }
3174 else if (data.attack_mode == ATTACK_MODE_BF)
3175 {
3176 u64 off = innerloop_pos;
3177
3178 device_param->kernel_params_mp_r_buf64[3] = off;
3179
3180 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3181 }
3182 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3183 {
3184 u64 off = innerloop_pos;
3185
3186 device_param->kernel_params_mp_buf64[3] = off;
3187
3188 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3189 }
3190 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3191 {
3192 u64 off = innerloop_pos;
3193
3194 device_param->kernel_params_mp_buf64[3] = off;
3195
3196 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3197 }
3198
3199 // copy amplifiers
3200
3201 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3202 {
3203 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);
3204 }
3205 else if (data.attack_mode == ATTACK_MODE_COMBI)
3206 {
3207 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);
3208 }
3209 else if (data.attack_mode == ATTACK_MODE_BF)
3210 {
3211 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);
3212 }
3213 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3214 {
3215 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);
3216 }
3217 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3218 {
3219 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);
3220 }
3221
3222 if (data.benchmark == 1)
3223 {
3224 hc_timer_set (&device_param->timer_speed);
3225 }
3226
3227 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3228
3229 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3230
3231 if (data.devices_status == STATUS_CRACKED) break;
3232 if (data.devices_status == STATUS_ABORTED) break;
3233 if (data.devices_status == STATUS_QUIT) break;
3234
3235 /**
3236 * result
3237 */
3238
3239 hc_thread_mutex_lock (mux_display);
3240
3241 check_cracked (device_param, salt_pos);
3242
3243 hc_thread_mutex_unlock (mux_display);
3244
3245 /**
3246 * progress
3247 */
3248
3249 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3250
3251 hc_thread_mutex_lock (mux_counter);
3252
3253 data.words_progress_done[salt_pos] += perf_sum_all;
3254
3255 hc_thread_mutex_unlock (mux_counter);
3256
3257 /**
3258 * speed
3259 */
3260
3261 double speed_ms;
3262
3263 hc_timer_get (device_param->timer_speed, speed_ms);
3264
3265 hc_timer_set (&device_param->timer_speed);
3266
3267 hc_thread_mutex_lock (mux_display);
3268
3269 // current speed
3270
3271 device_param->speed_cnt[speed_pos] = perf_sum_all;
3272
3273 device_param->speed_ms[speed_pos] = speed_ms;
3274
3275 hc_thread_mutex_unlock (mux_display);
3276
3277 speed_pos++;
3278
3279 if (speed_pos == SPEED_CACHE)
3280 {
3281 speed_pos = 0;
3282 }
3283
3284 /**
3285 * benchmark
3286 */
3287
3288 if (data.benchmark == 1) break;
3289 }
3290 }
3291
3292 device_param->speed_pos = speed_pos;
3293
3294 myfree (line_buf);
3295 }
3296
3297 static void load_segment (wl_data_t *wl_data, FILE *fd)
3298 {
3299 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3300
3301 wl_data->pos = 0;
3302
3303 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3304
3305 wl_data->buf[wl_data->cnt] = 0;
3306
3307 if (wl_data->cnt == 0) return;
3308
3309 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3310
3311 while (!feof (fd))
3312 {
3313 if (wl_data->cnt == wl_data->avail)
3314 {
3315 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3316
3317 wl_data->avail += wl_data->incr;
3318 }
3319
3320 const int c = fgetc (fd);
3321
3322 if (c == EOF) break;
3323
3324 wl_data->buf[wl_data->cnt] = (char) c;
3325
3326 wl_data->cnt++;
3327
3328 if (c == '\n') break;
3329 }
3330
3331 // ensure stream ends with a newline
3332
3333 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3334 {
3335 wl_data->cnt++;
3336
3337 wl_data->buf[wl_data->cnt - 1] = '\n';
3338 }
3339
3340 return;
3341 }
3342
3343 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3344 {
3345 char *ptr = buf;
3346
3347 for (u32 i = 0; i < sz; i++, ptr++)
3348 {
3349 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3350
3351 if (i == 7)
3352 {
3353 *off = i;
3354 *len = i;
3355
3356 return;
3357 }
3358
3359 if (*ptr != '\n') continue;
3360
3361 *off = i + 1;
3362
3363 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3364
3365 *len = i;
3366
3367 return;
3368 }
3369
3370 *off = sz;
3371 *len = sz;
3372 }
3373
3374 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3375 {
3376 char *ptr = buf;
3377
3378 for (u32 i = 0; i < sz; i++, ptr++)
3379 {
3380 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3381
3382 if (*ptr != '\n') continue;
3383
3384 *off = i + 1;
3385
3386 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3387
3388 *len = i;
3389
3390 return;
3391 }
3392
3393 *off = sz;
3394 *len = sz;
3395 }
3396
3397 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3398 {
3399 char *ptr = buf;
3400
3401 for (u32 i = 0; i < sz; i++, ptr++)
3402 {
3403 if (*ptr != '\n') continue;
3404
3405 *off = i + 1;
3406
3407 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3408
3409 *len = i;
3410
3411 return;
3412 }
3413
3414 *off = sz;
3415 *len = sz;
3416 }
3417
3418 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3419 {
3420 while (wl_data->pos < wl_data->cnt)
3421 {
3422 uint off;
3423 uint len;
3424
3425 char *ptr = wl_data->buf + wl_data->pos;
3426
3427 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3428
3429 wl_data->pos += off;
3430
3431 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3432 {
3433 char rule_buf_out[BLOCK_SIZE] = { 0 };
3434
3435 int rule_len_out = -1;
3436
3437 if (len < BLOCK_SIZE)
3438 {
3439 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3440 }
3441
3442 if (rule_len_out < 0)
3443 {
3444 continue;
3445 }
3446
3447 if (rule_len_out > PW_MAX)
3448 {
3449 continue;
3450 }
3451 }
3452 else
3453 {
3454 if (len > PW_MAX)
3455 {
3456 continue;
3457 }
3458 }
3459
3460 *out_buf = ptr;
3461 *out_len = len;
3462
3463 return;
3464 }
3465
3466 if (feof (fd))
3467 {
3468 fprintf (stderr, "BUG feof()!!\n");
3469
3470 return;
3471 }
3472
3473 load_segment (wl_data, fd);
3474
3475 get_next_word (wl_data, fd, out_buf, out_len);
3476 }
3477
3478 #ifdef _POSIX
3479 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3480 #endif
3481
3482 #ifdef _WIN
3483 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3484 #endif
3485 {
3486 hc_signal (NULL);
3487
3488 dictstat_t d;
3489
3490 d.cnt = 0;
3491
3492 #ifdef _POSIX
3493 fstat (fileno (fd), &d.stat);
3494 #endif
3495
3496 #ifdef _WIN
3497 _fstat64 (fileno (fd), &d.stat);
3498 #endif
3499
3500 d.stat.st_mode = 0;
3501 d.stat.st_nlink = 0;
3502 d.stat.st_uid = 0;
3503 d.stat.st_gid = 0;
3504 d.stat.st_rdev = 0;
3505 d.stat.st_atime = 0;
3506
3507 #ifdef _POSIX
3508 d.stat.st_blksize = 0;
3509 d.stat.st_blocks = 0;
3510 #endif
3511
3512 if (d.stat.st_size == 0) return 0;
3513
3514 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3515
3516 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3517 {
3518 if (d_cache)
3519 {
3520 u64 cnt = d_cache->cnt;
3521
3522 u64 keyspace = cnt;
3523
3524 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3525 {
3526 keyspace *= data.kernel_rules_cnt;
3527 }
3528 else if (data.attack_kern == ATTACK_KERN_COMBI)
3529 {
3530 keyspace *= data.combs_cnt;
3531 }
3532
3533 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);
3534 if (data.quiet == 0) log_info ("");
3535
3536 hc_signal (sigHandler_default);
3537
3538 return (keyspace);
3539 }
3540 }
3541
3542 time_t now = 0;
3543 time_t prev = 0;
3544
3545 u64 comp = 0;
3546 u64 cnt = 0;
3547 u64 cnt2 = 0;
3548
3549 while (!feof (fd))
3550 {
3551 load_segment (wl_data, fd);
3552
3553 comp += wl_data->cnt;
3554
3555 u32 i = 0;
3556
3557 while (i < wl_data->cnt)
3558 {
3559 u32 len;
3560 u32 off;
3561
3562 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3563
3564 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3565 {
3566 char rule_buf_out[BLOCK_SIZE] = { 0 };
3567
3568 int rule_len_out = -1;
3569
3570 if (len < BLOCK_SIZE)
3571 {
3572 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3573 }
3574
3575 if (rule_len_out < 0)
3576 {
3577 len = PW_MAX1;
3578 }
3579 else
3580 {
3581 len = rule_len_out;
3582 }
3583 }
3584
3585 if (len < PW_MAX1)
3586 {
3587 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3588 {
3589 cnt += data.kernel_rules_cnt;
3590 }
3591 else if (data.attack_kern == ATTACK_KERN_COMBI)
3592 {
3593 cnt += data.combs_cnt;
3594 }
3595
3596 d.cnt++;
3597 }
3598
3599 i += off;
3600
3601 cnt2++;
3602 }
3603
3604 time (&now);
3605
3606 if ((now - prev) == 0) continue;
3607
3608 float percent = (float) comp / (float) d.stat.st_size;
3609
3610 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);
3611
3612 time (&prev);
3613 }
3614
3615 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);
3616 if (data.quiet == 0) log_info ("");
3617
3618 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3619
3620 hc_signal (sigHandler_default);
3621
3622 return (cnt);
3623 }
3624
3625 static void *thread_monitor (void *p)
3626 {
3627 uint runtime_check = 0;
3628 uint remove_check = 0;
3629 uint status_check = 0;
3630 uint restore_check = 0;
3631
3632 uint restore_left = data.restore_timer;
3633 uint remove_left = data.remove_timer;
3634 uint status_left = data.status_timer;
3635
3636 #ifdef HAVE_HWMON
3637 uint hwmon_check = 0;
3638
3639 // these variables are mainly used for fan control (AMD only)
3640
3641 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3642
3643 // temperature controller "loopback" values
3644
3645 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3646 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3647
3648 #ifdef HAVE_ADL
3649 int temp_threshold = 1; // degrees celcius
3650
3651 int fan_speed_min = 15; // in percentage
3652 int fan_speed_max = 100;
3653 #endif // HAVE_ADL
3654
3655 time_t last_temp_check_time;
3656 #endif // HAVE_HWMON
3657
3658 uint sleep_time = 1;
3659
3660 if (data.runtime)
3661 {
3662 runtime_check = 1;
3663 }
3664
3665 if (data.restore_timer)
3666 {
3667 restore_check = 1;
3668 }
3669
3670 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3671 {
3672 remove_check = 1;
3673 }
3674
3675 if (data.status == 1)
3676 {
3677 status_check = 1;
3678 }
3679
3680 #ifdef HAVE_HWMON
3681 if (data.gpu_temp_disable == 0)
3682 {
3683 time (&last_temp_check_time);
3684
3685 hwmon_check = 1;
3686 }
3687 #endif
3688
3689 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3690 {
3691 #ifdef HAVE_HWMON
3692 if (hwmon_check == 0)
3693 #endif
3694 return (p);
3695 }
3696
3697 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3698 {
3699 hc_sleep (sleep_time);
3700
3701 if (data.devices_status != STATUS_RUNNING) continue;
3702
3703 #ifdef HAVE_HWMON
3704 if (hwmon_check == 1)
3705 {
3706 hc_thread_mutex_lock (mux_adl);
3707
3708 time_t temp_check_time;
3709
3710 time (&temp_check_time);
3711
3712 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3713
3714 if (Ta == 0) Ta = 1;
3715
3716 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3717 {
3718 hc_device_param_t *device_param = &data.devices_param[device_id];
3719
3720 if (device_param->skipped) continue;
3721
3722 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3723
3724 const int temperature = hm_get_temperature_with_device_id (device_id);
3725
3726 if (temperature > (int) data.gpu_temp_abort)
3727 {
3728 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3729
3730 if (data.devices_status != STATUS_QUIT) myabort ();
3731
3732 break;
3733 }
3734
3735 #ifdef HAVE_ADL
3736 const int gpu_temp_retain = data.gpu_temp_retain;
3737
3738 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3739 {
3740 if (data.hm_device[device_id].fan_supported == 1)
3741 {
3742 int temp_cur = temperature;
3743
3744 int temp_diff_new = gpu_temp_retain - temp_cur;
3745
3746 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3747
3748 // calculate Ta value (time difference in seconds between the last check and this check)
3749
3750 last_temp_check_time = temp_check_time;
3751
3752 float Kp = 1.8;
3753 float Ki = 0.005;
3754 float Kd = 6;
3755
3756 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3757
3758 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);
3759
3760 if (abs (fan_diff_required) >= temp_threshold)
3761 {
3762 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3763
3764 int fan_speed_level = fan_speed_cur;
3765
3766 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3767
3768 int fan_speed_new = fan_speed_level - fan_diff_required;
3769
3770 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3771 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3772
3773 if (fan_speed_new != fan_speed_cur)
3774 {
3775 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3776 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3777
3778 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3779 {
3780 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3781
3782 fan_speed_chgd[device_id] = 1;
3783 }
3784
3785 temp_diff_old[device_id] = temp_diff_new;
3786 }
3787 }
3788 }
3789 }
3790 #endif // HAVE_ADL
3791 }
3792
3793 hc_thread_mutex_unlock (mux_adl);
3794 }
3795 #endif // HAVE_HWMON
3796
3797 if (restore_check == 1)
3798 {
3799 restore_left--;
3800
3801 if (restore_left == 0)
3802 {
3803 if (data.restore_disable == 0) cycle_restore ();
3804
3805 restore_left = data.restore_timer;
3806 }
3807 }
3808
3809 if ((runtime_check == 1) && (data.runtime_start > 0))
3810 {
3811 time_t runtime_cur;
3812
3813 time (&runtime_cur);
3814
3815 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3816
3817 if (runtime_left <= 0)
3818 {
3819 if (data.benchmark == 0)
3820 {
3821 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3822 }
3823
3824 if (data.devices_status != STATUS_QUIT) myabort ();
3825 }
3826 }
3827
3828 if (remove_check == 1)
3829 {
3830 remove_left--;
3831
3832 if (remove_left == 0)
3833 {
3834 if (data.digests_saved != data.digests_done)
3835 {
3836 data.digests_saved = data.digests_done;
3837
3838 save_hash ();
3839 }
3840
3841 remove_left = data.remove_timer;
3842 }
3843 }
3844
3845 if (status_check == 1)
3846 {
3847 status_left--;
3848
3849 if (status_left == 0)
3850 {
3851 hc_thread_mutex_lock (mux_display);
3852
3853 if (data.quiet == 0) clear_prompt ();
3854
3855 if (data.quiet == 0) log_info ("");
3856
3857 status_display ();
3858
3859 if (data.quiet == 0) log_info ("");
3860
3861 hc_thread_mutex_unlock (mux_display);
3862
3863 status_left = data.status_timer;
3864 }
3865 }
3866 }
3867
3868 #ifdef HAVE_HWMON
3869 myfree (fan_speed_chgd);
3870
3871 myfree (temp_diff_old);
3872 myfree (temp_diff_sum);
3873 #endif
3874
3875 p = NULL;
3876
3877 return (p);
3878 }
3879
3880 static void *thread_outfile_remove (void *p)
3881 {
3882 // some hash-dependent constants
3883 char *outfile_dir = data.outfile_check_directory;
3884 uint dgst_size = data.dgst_size;
3885 uint isSalted = data.isSalted;
3886 uint esalt_size = data.esalt_size;
3887 uint hash_mode = data.hash_mode;
3888
3889 uint outfile_check_timer = data.outfile_check_timer;
3890
3891 char separator = data.separator;
3892
3893 // some hash-dependent functions
3894 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3895 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3896
3897 // buffers
3898 hash_t hash_buf = { 0, 0, 0, 0, 0 };
3899
3900 hash_buf.digest = mymalloc (dgst_size);
3901
3902 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3903
3904 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3905
3906 uint digest_buf[64] = { 0 };
3907
3908 outfile_data_t *out_info = NULL;
3909
3910 char **out_files = NULL;
3911
3912 time_t folder_mtime = 0;
3913
3914 int out_cnt = 0;
3915
3916 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
3917
3918 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3919 {
3920 hc_sleep (1);
3921
3922 if (data.devices_status != STATUS_RUNNING) continue;
3923
3924 check_left--;
3925
3926 if (check_left == 0)
3927 {
3928 struct stat outfile_check_stat;
3929
3930 if (stat (outfile_dir, &outfile_check_stat) == 0)
3931 {
3932 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
3933
3934 if (is_dir == 1)
3935 {
3936 if (outfile_check_stat.st_mtime > folder_mtime)
3937 {
3938 char **out_files_new = scan_directory (outfile_dir);
3939
3940 int out_cnt_new = count_dictionaries (out_files_new);
3941
3942 outfile_data_t *out_info_new = NULL;
3943
3944 if (out_cnt_new > 0)
3945 {
3946 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
3947
3948 for (int i = 0; i < out_cnt_new; i++)
3949 {
3950 out_info_new[i].file_name = out_files_new[i];
3951
3952 // check if there are files that we have seen/checked before (and not changed)
3953
3954 for (int j = 0; j < out_cnt; j++)
3955 {
3956 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
3957 {
3958 struct stat outfile_stat;
3959
3960 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
3961 {
3962 if (outfile_stat.st_ctime == out_info[j].ctime)
3963 {
3964 out_info_new[i].ctime = out_info[j].ctime;
3965 out_info_new[i].seek = out_info[j].seek;
3966 }
3967 }
3968 }
3969 }
3970 }
3971 }
3972
3973 local_free (out_info);
3974 local_free (out_files);
3975
3976 out_files = out_files_new;
3977 out_cnt = out_cnt_new;
3978 out_info = out_info_new;
3979
3980 folder_mtime = outfile_check_stat.st_mtime;
3981 }
3982
3983 for (int j = 0; j < out_cnt; j++)
3984 {
3985 FILE *fp = fopen (out_info[j].file_name, "rb");
3986
3987 if (fp != NULL)
3988 {
3989 //hc_thread_mutex_lock (mux_display);
3990
3991 #ifdef _POSIX
3992 struct stat outfile_stat;
3993
3994 fstat (fileno (fp), &outfile_stat);
3995 #endif
3996
3997 #ifdef _WIN
3998 struct stat64 outfile_stat;
3999
4000 _fstat64 (fileno (fp), &outfile_stat);
4001 #endif
4002
4003 if (outfile_stat.st_ctime > out_info[j].ctime)
4004 {
4005 out_info[j].ctime = outfile_stat.st_ctime;
4006 out_info[j].seek = 0;
4007 }
4008
4009 fseek (fp, out_info[j].seek, SEEK_SET);
4010
4011 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4012
4013 while (!feof (fp))
4014 {
4015 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4016
4017 if (ptr == NULL) break;
4018
4019 int line_len = strlen (line_buf);
4020
4021 if (line_len <= 0) continue;
4022
4023 int iter = MAX_CUT_TRIES;
4024
4025 for (uint i = line_len - 1; i && iter; i--, line_len--)
4026 {
4027 if (line_buf[i] != separator) continue;
4028
4029 int parser_status = PARSER_OK;
4030
4031 if ((hash_mode != 2500) && (hash_mode != 6800))
4032 {
4033 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4034 }
4035
4036 uint found = 0;
4037
4038 if (parser_status == PARSER_OK)
4039 {
4040 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4041 {
4042 if (data.salts_shown[salt_pos] == 1) continue;
4043
4044 salt_t *salt_buf = &data.salts_buf[salt_pos];
4045
4046 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4047 {
4048 uint idx = salt_buf->digests_offset + digest_pos;
4049
4050 if (data.digests_shown[idx] == 1) continue;
4051
4052 uint cracked = 0;
4053
4054 if (hash_mode == 6800)
4055 {
4056 if (i == salt_buf->salt_len)
4057 {
4058 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4059 }
4060 }
4061 else if (hash_mode == 2500)
4062 {
4063 // BSSID : MAC1 : MAC2 (:plain)
4064 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4065 {
4066 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4067
4068 if (!cracked) continue;
4069
4070 // now compare MAC1 and MAC2 too, since we have this additional info
4071 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4072 char *mac2_pos = mac1_pos + 12 + 1;
4073
4074 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4075 wpa_t *wpa = &wpas[salt_pos];
4076
4077 // compare hex string(s) vs binary MAC address(es)
4078
4079 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4080 {
4081 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4082 {
4083 cracked = 0;
4084
4085 break;
4086 }
4087 }
4088
4089 // early skip ;)
4090 if (!cracked) continue;
4091
4092 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4093 {
4094 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4095 {
4096 cracked = 0;
4097
4098 break;
4099 }
4100 }
4101 }
4102 }
4103 else
4104 {
4105 char *digests_buf_ptr = (char *) data.digests_buf;
4106
4107 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4108
4109 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4110 }
4111
4112 if (cracked == 1)
4113 {
4114 found = 1;
4115
4116 data.digests_shown[idx] = 1;
4117
4118 data.digests_done++;
4119
4120 salt_buf->digests_done++;
4121
4122 if (salt_buf->digests_done == salt_buf->digests_cnt)
4123 {
4124 data.salts_shown[salt_pos] = 1;
4125
4126 data.salts_done++;
4127
4128 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4129 }
4130 }
4131 }
4132
4133 if (data.devices_status == STATUS_CRACKED) break;
4134 }
4135 }
4136
4137 if (found) break;
4138
4139 if (data.devices_status == STATUS_CRACKED) break;
4140
4141 iter--;
4142 }
4143
4144 if (data.devices_status == STATUS_CRACKED) break;
4145 }
4146
4147 myfree (line_buf);
4148
4149 out_info[j].seek = ftell (fp);
4150
4151 //hc_thread_mutex_unlock (mux_display);
4152
4153 fclose (fp);
4154 }
4155 }
4156 }
4157 }
4158
4159 check_left = outfile_check_timer;
4160 }
4161 }
4162
4163 if (esalt_size) local_free (hash_buf.esalt);
4164
4165 if (isSalted) local_free (hash_buf.salt);
4166
4167 local_free (hash_buf.digest);
4168
4169 local_free (out_info);
4170
4171 local_free (out_files);
4172
4173 p = NULL;
4174
4175 return (p);
4176 }
4177
4178 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4179 {
4180 if (device_param->pws_cnt < device_param->kernel_power)
4181 {
4182 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4183
4184 u8 *ptr = (u8 *) pw->i;
4185
4186 memcpy (ptr, pw_buf, pw_len);
4187
4188 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4189
4190 pw->pw_len = pw_len;
4191
4192 device_param->pws_cnt++;
4193 }
4194 else
4195 {
4196 fprintf (stderr, "BUG pw_add()!!\n");
4197
4198 return;
4199 }
4200 }
4201
4202 static uint get_work (hc_device_param_t *device_param, const u64 max, const bool allow_div)
4203 {
4204 hc_thread_mutex_lock (mux_dispatcher);
4205
4206 const u64 words_cur = data.words_cur;
4207 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4208
4209 device_param->words_off = words_cur;
4210
4211 const u64 words_left = words_base - words_cur;
4212
4213 if (allow_div)
4214 {
4215 if (data.kernel_power_all > words_left)
4216 {
4217 if (data.kernel_power_div == 0)
4218 {
4219 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4220 }
4221 }
4222
4223 if (data.kernel_power_div)
4224 {
4225 if (device_param->kernel_power == device_param->kernel_power_user)
4226 {
4227 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4228
4229 if (kernel_power_new < device_param->kernel_power)
4230 {
4231 device_param->kernel_power = kernel_power_new;
4232 }
4233 }
4234 }
4235 }
4236
4237 const uint kernel_power = device_param->kernel_power;
4238
4239 uint work = MIN (words_left, kernel_power);
4240
4241 work = MIN (work, max);
4242
4243 data.words_cur += work;
4244
4245 hc_thread_mutex_unlock (mux_dispatcher);
4246
4247 return work;
4248 }
4249
4250 static void *thread_calc_stdin (void *p)
4251 {
4252 hc_device_param_t *device_param = (hc_device_param_t *) p;
4253
4254 if (device_param->skipped) return NULL;
4255
4256 autotune (device_param);
4257
4258 char *buf = (char *) mymalloc (HCBUFSIZ);
4259
4260 const uint attack_kern = data.attack_kern;
4261
4262 const uint kernel_power = device_param->kernel_power;
4263
4264 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4265 {
4266 hc_thread_mutex_lock (mux_dispatcher);
4267
4268 if (feof (stdin) != 0)
4269 {
4270 hc_thread_mutex_unlock (mux_dispatcher);
4271
4272 break;
4273 }
4274
4275 uint words_cur = 0;
4276
4277 while (words_cur < kernel_power)
4278 {
4279 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4280
4281 if (line_buf == NULL) break;
4282
4283 uint line_len = in_superchop (line_buf);
4284
4285 line_len = convert_from_hex (line_buf, line_len);
4286
4287 // post-process rule engine
4288
4289 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4290 {
4291 char rule_buf_out[BLOCK_SIZE] = { 0 };
4292
4293 int rule_len_out = -1;
4294
4295 if (line_len < BLOCK_SIZE)
4296 {
4297 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4298 }
4299
4300 if (rule_len_out < 0) continue;
4301
4302 line_buf = rule_buf_out;
4303 line_len = rule_len_out;
4304 }
4305
4306 if (line_len > PW_MAX)
4307 {
4308 continue;
4309 }
4310
4311 if (attack_kern == ATTACK_KERN_STRAIGHT)
4312 {
4313 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4314 {
4315 hc_thread_mutex_lock (mux_counter);
4316
4317 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4318 {
4319 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4320 }
4321
4322 hc_thread_mutex_unlock (mux_counter);
4323
4324 continue;
4325 }
4326 }
4327 else if (attack_kern == ATTACK_KERN_COMBI)
4328 {
4329 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4330 // since we still need to combine the plains
4331
4332 if (line_len > data.pw_max)
4333 {
4334 hc_thread_mutex_lock (mux_counter);
4335
4336 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4337 {
4338 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4339 }
4340
4341 hc_thread_mutex_unlock (mux_counter);
4342
4343 continue;
4344 }
4345 }
4346
4347 pw_add (device_param, (u8 *) line_buf, line_len);
4348
4349 words_cur++;
4350
4351 if (data.devices_status == STATUS_CRACKED) break;
4352 if (data.devices_status == STATUS_ABORTED) break;
4353 if (data.devices_status == STATUS_QUIT) break;
4354 if (data.devices_status == STATUS_BYPASS) break;
4355 }
4356
4357 hc_thread_mutex_unlock (mux_dispatcher);
4358
4359 if (data.devices_status == STATUS_CRACKED) break;
4360 if (data.devices_status == STATUS_ABORTED) break;
4361 if (data.devices_status == STATUS_QUIT) break;
4362 if (data.devices_status == STATUS_BYPASS) break;
4363
4364 // flush
4365
4366 const uint pws_cnt = device_param->pws_cnt;
4367
4368 if (pws_cnt)
4369 {
4370 run_copy (device_param, pws_cnt);
4371
4372 run_cracker (device_param, pws_cnt);
4373
4374 device_param->pws_cnt = 0;
4375
4376 if (attack_kern == ATTACK_KERN_STRAIGHT)
4377 {
4378 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4379 }
4380 else if (attack_kern == ATTACK_KERN_COMBI)
4381 {
4382 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4383 }
4384 }
4385 }
4386
4387 device_param->kernel_accel = 0;
4388 device_param->kernel_loops = 0;
4389
4390 myfree (buf);
4391
4392 return NULL;
4393 }
4394
4395 static void *thread_calc (void *p)
4396 {
4397 hc_device_param_t *device_param = (hc_device_param_t *) p;
4398
4399 if (device_param->skipped) return NULL;
4400
4401 autotune (device_param);
4402
4403 const uint attack_mode = data.attack_mode;
4404 const uint attack_kern = data.attack_kern;
4405
4406 if (attack_mode == ATTACK_MODE_BF)
4407 {
4408 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4409 {
4410 const uint work = get_work (device_param, -1, true);
4411
4412 if (work == 0) break;
4413
4414 const u64 words_off = device_param->words_off;
4415 const u64 words_fin = words_off + work;
4416
4417 const uint pws_cnt = work;
4418
4419 device_param->pws_cnt = pws_cnt;
4420
4421 if (pws_cnt)
4422 {
4423 run_copy (device_param, pws_cnt);
4424
4425 run_cracker (device_param, pws_cnt);
4426
4427 device_param->pws_cnt = 0;
4428
4429 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4430 }
4431
4432 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4433
4434 if (data.devices_status == STATUS_CRACKED) break;
4435 if (data.devices_status == STATUS_ABORTED) break;
4436 if (data.devices_status == STATUS_QUIT) break;
4437 if (data.devices_status == STATUS_BYPASS) break;
4438
4439 if (data.benchmark == 1) break;
4440
4441 device_param->words_done = words_fin;
4442 }
4443 }
4444 else
4445 {
4446 const uint segment_size = data.segment_size;
4447
4448 char *dictfile = data.dictfile;
4449
4450 if (attack_mode == ATTACK_MODE_COMBI)
4451 {
4452 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4453 {
4454 dictfile = data.dictfile2;
4455 }
4456 }
4457
4458 FILE *fd = fopen (dictfile, "rb");
4459
4460 if (fd == NULL)
4461 {
4462 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4463
4464 return NULL;
4465 }
4466
4467 if (attack_mode == ATTACK_MODE_COMBI)
4468 {
4469 const uint combs_mode = data.combs_mode;
4470
4471 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4472 {
4473 const char *dictfilec = data.dictfile2;
4474
4475 FILE *combs_fp = fopen (dictfilec, "rb");
4476
4477 if (combs_fp == NULL)
4478 {
4479 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4480
4481 fclose (fd);
4482
4483 return NULL;
4484 }
4485
4486 device_param->combs_fp = combs_fp;
4487 }
4488 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4489 {
4490 const char *dictfilec = data.dictfile;
4491
4492 FILE *combs_fp = fopen (dictfilec, "rb");
4493
4494 if (combs_fp == NULL)
4495 {
4496 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4497
4498 fclose (fd);
4499
4500 return NULL;
4501 }
4502
4503 device_param->combs_fp = combs_fp;
4504 }
4505 }
4506
4507 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4508
4509 wl_data->buf = (char *) mymalloc (segment_size);
4510 wl_data->avail = segment_size;
4511 wl_data->incr = segment_size;
4512 wl_data->cnt = 0;
4513 wl_data->pos = 0;
4514
4515 u64 words_cur = 0;
4516
4517 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4518 {
4519 u64 words_off = 0;
4520 u64 words_fin = 0;
4521
4522 bool allow_div = true;
4523
4524 u64 max = -1;
4525
4526 while (max)
4527 {
4528 const uint work = get_work (device_param, max, allow_div);
4529
4530 allow_div = false;
4531
4532 if (work == 0) break;
4533
4534 words_off = device_param->words_off;
4535 words_fin = words_off + work;
4536
4537 char *line_buf;
4538 uint line_len;
4539
4540 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4541
4542 max = 0;
4543
4544 for ( ; words_cur < words_fin; words_cur++)
4545 {
4546 get_next_word (wl_data, fd, &line_buf, &line_len);
4547
4548 line_len = convert_from_hex (line_buf, line_len);
4549
4550 // post-process rule engine
4551
4552 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4553 {
4554 char rule_buf_out[BLOCK_SIZE] = { 0 };
4555
4556 int rule_len_out = -1;
4557
4558 if (line_len < BLOCK_SIZE)
4559 {
4560 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4561 }
4562
4563 if (rule_len_out < 0) continue;
4564
4565 line_buf = rule_buf_out;
4566 line_len = rule_len_out;
4567 }
4568
4569 if (attack_kern == ATTACK_KERN_STRAIGHT)
4570 {
4571 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4572 {
4573 max++;
4574
4575 hc_thread_mutex_lock (mux_counter);
4576
4577 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4578 {
4579 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4580 }
4581
4582 hc_thread_mutex_unlock (mux_counter);
4583
4584 continue;
4585 }
4586 }
4587 else if (attack_kern == ATTACK_KERN_COMBI)
4588 {
4589 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4590 // since we still need to combine the plains
4591
4592 if (line_len > data.pw_max)
4593 {
4594 max++;
4595
4596 hc_thread_mutex_lock (mux_counter);
4597
4598 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4599 {
4600 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4601 }
4602
4603 hc_thread_mutex_unlock (mux_counter);
4604
4605 continue;
4606 }
4607 }
4608
4609 pw_add (device_param, (u8 *) line_buf, line_len);
4610
4611 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4612
4613 if (data.devices_status == STATUS_CRACKED) break;
4614 if (data.devices_status == STATUS_ABORTED) break;
4615 if (data.devices_status == STATUS_QUIT) break;
4616 if (data.devices_status == STATUS_BYPASS) break;
4617 }
4618
4619 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4620
4621 if (data.devices_status == STATUS_CRACKED) break;
4622 if (data.devices_status == STATUS_ABORTED) break;
4623 if (data.devices_status == STATUS_QUIT) break;
4624 if (data.devices_status == STATUS_BYPASS) break;
4625 }
4626
4627 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4628
4629 if (data.devices_status == STATUS_CRACKED) break;
4630 if (data.devices_status == STATUS_ABORTED) break;
4631 if (data.devices_status == STATUS_QUIT) break;
4632 if (data.devices_status == STATUS_BYPASS) break;
4633
4634 //
4635 // flush
4636 //
4637
4638 const uint pws_cnt = device_param->pws_cnt;
4639
4640 if (pws_cnt)
4641 {
4642 run_copy (device_param, pws_cnt);
4643
4644 run_cracker (device_param, pws_cnt);
4645
4646 device_param->pws_cnt = 0;
4647
4648 if (attack_kern == ATTACK_KERN_STRAIGHT)
4649 {
4650 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4651 }
4652 else if (attack_kern == ATTACK_KERN_COMBI)
4653 {
4654 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4655 }
4656 }
4657
4658 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4659
4660 if (data.devices_status == STATUS_CRACKED) break;
4661 if (data.devices_status == STATUS_ABORTED) break;
4662 if (data.devices_status == STATUS_QUIT) break;
4663 if (data.devices_status == STATUS_BYPASS) break;
4664
4665 if (words_fin == 0) break;
4666
4667 device_param->words_done = words_fin;
4668 }
4669
4670 if (attack_mode == ATTACK_MODE_COMBI)
4671 {
4672 fclose (device_param->combs_fp);
4673 }
4674
4675 free (wl_data->buf);
4676 free (wl_data);
4677
4678 fclose (fd);
4679 }
4680
4681 device_param->kernel_accel = 0;
4682 device_param->kernel_loops = 0;
4683
4684 return NULL;
4685 }
4686
4687 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4688 {
4689 if (!device_param)
4690 {
4691 log_error ("ERROR: %s : Invalid argument", __func__);
4692
4693 exit (-1);
4694 }
4695
4696 salt_t *salt_buf = &data.salts_buf[salt_pos];
4697
4698 device_param->kernel_params_buf32[24] = salt_pos;
4699 device_param->kernel_params_buf32[27] = 1;
4700 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4701 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4702 device_param->kernel_params_buf32[30] = 0;
4703 device_param->kernel_params_buf32[31] = 1;
4704
4705 char *dictfile_old = data.dictfile;
4706
4707 const char *weak_hash_check = "weak-hash-check";
4708
4709 data.dictfile = (char *) weak_hash_check;
4710
4711 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4712
4713 data.kernel_rules_buf[0].cmds[0] = 0;
4714
4715 /**
4716 * run the kernel
4717 */
4718
4719 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4720 {
4721 run_kernel (KERN_RUN_1, device_param, 1, false);
4722 }
4723 else
4724 {
4725 run_kernel (KERN_RUN_1, device_param, 1, false);
4726
4727 uint loop_step = 16;
4728
4729 const uint iter = salt_buf->salt_iter;
4730
4731 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4732 {
4733 uint loop_left = iter - loop_pos;
4734
4735 loop_left = MIN (loop_left, loop_step);
4736
4737 device_param->kernel_params_buf32[25] = loop_pos;
4738 device_param->kernel_params_buf32[26] = loop_left;
4739
4740 run_kernel (KERN_RUN_2, device_param, 1, false);
4741 }
4742
4743 run_kernel (KERN_RUN_3, device_param, 1, false);
4744 }
4745
4746 /**
4747 * result
4748 */
4749
4750 check_cracked (device_param, salt_pos);
4751
4752 /**
4753 * cleanup
4754 */
4755
4756 device_param->kernel_params_buf32[24] = 0;
4757 device_param->kernel_params_buf32[25] = 0;
4758 device_param->kernel_params_buf32[26] = 0;
4759 device_param->kernel_params_buf32[27] = 0;
4760 device_param->kernel_params_buf32[28] = 0;
4761 device_param->kernel_params_buf32[29] = 0;
4762 device_param->kernel_params_buf32[30] = 0;
4763 device_param->kernel_params_buf32[31] = 0;
4764
4765 data.dictfile = dictfile_old;
4766
4767 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4768 }
4769
4770 // hlfmt hashcat
4771
4772 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4773 {
4774 if (data.username == 0)
4775 {
4776 *hashbuf_pos = line_buf;
4777 *hashbuf_len = line_len;
4778 }
4779 else
4780 {
4781 char *pos = line_buf;
4782 int len = line_len;
4783
4784 for (int i = 0; i < line_len; i++, pos++, len--)
4785 {
4786 if (line_buf[i] == data.separator)
4787 {
4788 pos++;
4789
4790 len--;
4791
4792 break;
4793 }
4794 }
4795
4796 *hashbuf_pos = pos;
4797 *hashbuf_len = len;
4798 }
4799 }
4800
4801 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4802 {
4803 char *pos = NULL;
4804 int len = 0;
4805
4806 int sep_cnt = 0;
4807
4808 for (int i = 0; i < line_len; i++)
4809 {
4810 if (line_buf[i] == data.separator)
4811 {
4812 sep_cnt++;
4813
4814 continue;
4815 }
4816
4817 if (sep_cnt == 0)
4818 {
4819 if (pos == NULL) pos = line_buf + i;
4820
4821 len++;
4822 }
4823 }
4824
4825 *userbuf_pos = pos;
4826 *userbuf_len = len;
4827 }
4828
4829 // hlfmt pwdump
4830
4831 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
4832 {
4833 int sep_cnt = 0;
4834
4835 int sep2_len = 0;
4836 int sep3_len = 0;
4837
4838 for (int i = 0; i < line_len; i++)
4839 {
4840 if (line_buf[i] == ':')
4841 {
4842 sep_cnt++;
4843
4844 continue;
4845 }
4846
4847 if (sep_cnt == 2) sep2_len++;
4848 if (sep_cnt == 3) sep3_len++;
4849 }
4850
4851 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4852
4853 return 0;
4854 }
4855
4856 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4857 {
4858 char *pos = NULL;
4859 int len = 0;
4860
4861 int sep_cnt = 0;
4862
4863 for (int i = 0; i < line_len; i++)
4864 {
4865 if (line_buf[i] == ':')
4866 {
4867 sep_cnt++;
4868
4869 continue;
4870 }
4871
4872 if (data.hash_mode == 1000)
4873 {
4874 if (sep_cnt == 3)
4875 {
4876 if (pos == NULL) pos = line_buf + i;
4877
4878 len++;
4879 }
4880 }
4881 else if (data.hash_mode == 3000)
4882 {
4883 if (sep_cnt == 2)
4884 {
4885 if (pos == NULL) pos = line_buf + i;
4886
4887 len++;
4888 }
4889 }
4890 }
4891
4892 *hashbuf_pos = pos;
4893 *hashbuf_len = len;
4894 }
4895
4896 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4897 {
4898 char *pos = NULL;
4899 int len = 0;
4900
4901 int sep_cnt = 0;
4902
4903 for (int i = 0; i < line_len; i++)
4904 {
4905 if (line_buf[i] == ':')
4906 {
4907 sep_cnt++;
4908
4909 continue;
4910 }
4911
4912 if (sep_cnt == 0)
4913 {
4914 if (pos == NULL) pos = line_buf + i;
4915
4916 len++;
4917 }
4918 }
4919
4920 *userbuf_pos = pos;
4921 *userbuf_len = len;
4922 }
4923
4924 // hlfmt passwd
4925
4926 static int hlfmt_detect_passwd (char *line_buf, int line_len)
4927 {
4928 int sep_cnt = 0;
4929
4930 char sep5_first = 0;
4931 char sep6_first = 0;
4932
4933 for (int i = 0; i < line_len; i++)
4934 {
4935 if (line_buf[i] == ':')
4936 {
4937 sep_cnt++;
4938
4939 continue;
4940 }
4941
4942 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
4943 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
4944 }
4945
4946 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
4947
4948 return 0;
4949 }
4950
4951 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4952 {
4953 char *pos = NULL;
4954 int len = 0;
4955
4956 int sep_cnt = 0;
4957
4958 for (int i = 0; i < line_len; i++)
4959 {
4960 if (line_buf[i] == ':')
4961 {
4962 sep_cnt++;
4963
4964 continue;
4965 }
4966
4967 if (sep_cnt == 1)
4968 {
4969 if (pos == NULL) pos = line_buf + i;
4970
4971 len++;
4972 }
4973 }
4974
4975 *hashbuf_pos = pos;
4976 *hashbuf_len = len;
4977 }
4978
4979 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4980 {
4981 char *pos = NULL;
4982 int len = 0;
4983
4984 int sep_cnt = 0;
4985
4986 for (int i = 0; i < line_len; i++)
4987 {
4988 if (line_buf[i] == ':')
4989 {
4990 sep_cnt++;
4991
4992 continue;
4993 }
4994
4995 if (sep_cnt == 0)
4996 {
4997 if (pos == NULL) pos = line_buf + i;
4998
4999 len++;
5000 }
5001 }
5002
5003 *userbuf_pos = pos;
5004 *userbuf_len = len;
5005 }
5006
5007 // hlfmt shadow
5008
5009 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5010 {
5011 int sep_cnt = 0;
5012
5013 for (int i = 0; i < line_len; i++)
5014 {
5015 if (line_buf[i] == ':') sep_cnt++;
5016 }
5017
5018 if (sep_cnt == 8) return 1;
5019
5020 return 0;
5021 }
5022
5023 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5024 {
5025 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5026 }
5027
5028 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5029 {
5030 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5031 }
5032
5033 // hlfmt main
5034
5035 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5036 {
5037 switch (hashfile_format)
5038 {
5039 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5040 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5041 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5042 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5043 }
5044 }
5045
5046 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5047 {
5048 switch (hashfile_format)
5049 {
5050 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5051 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5052 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5053 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5054 }
5055 }
5056
5057 char *strhlfmt (const uint hashfile_format)
5058 {
5059 switch (hashfile_format)
5060 {
5061 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5062 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5063 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5064 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5065 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5066 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5067 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5068 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5069 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5070 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5071 }
5072
5073 return ((char *) "Unknown");
5074 }
5075
5076 static uint hlfmt_detect (FILE *fp, uint max_check)
5077 {
5078 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5079
5080 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5081 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5082
5083 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5084
5085 uint num_check = 0;
5086
5087 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5088
5089 while (!feof (fp))
5090 {
5091 int line_len = fgetl (fp, line_buf);
5092
5093 if (line_len == 0) continue;
5094
5095 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5096 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5097 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5098
5099 if (num_check == max_check) break;
5100
5101 num_check++;
5102 }
5103
5104 myfree (line_buf);
5105
5106 uint hashlist_format = HLFMT_HASHCAT;
5107
5108 for (int i = 1; i < HLFMTS_CNT; i++)
5109 {
5110 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5111
5112 hashlist_format = i;
5113 }
5114
5115 free (formats_cnt);
5116
5117 return hashlist_format;
5118 }
5119
5120 /**
5121 * some further helper function
5122 */
5123
5124 // wrapper around mymalloc for ADL
5125
5126 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5127 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5128 {
5129 return mymalloc (iSize);
5130 }
5131 #endif
5132
5133 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)
5134 {
5135 u64 collisions = 0;
5136
5137 const uint dgst_pos0 = data.dgst_pos0;
5138 const uint dgst_pos1 = data.dgst_pos1;
5139 const uint dgst_pos2 = data.dgst_pos2;
5140 const uint dgst_pos3 = data.dgst_pos3;
5141
5142 memset (bitmap_a, 0, bitmap_size);
5143 memset (bitmap_b, 0, bitmap_size);
5144 memset (bitmap_c, 0, bitmap_size);
5145 memset (bitmap_d, 0, bitmap_size);
5146
5147 for (uint i = 0; i < digests_cnt; i++)
5148 {
5149 uint *digest_ptr = (uint *) digests_buf_ptr;
5150
5151 digests_buf_ptr += dgst_size;
5152
5153 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5154 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5155 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5156 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5157
5158 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5159 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5160 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5161 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5162
5163 if (bitmap_a[idx0] & val0) collisions++;
5164 if (bitmap_b[idx1] & val1) collisions++;
5165 if (bitmap_c[idx2] & val2) collisions++;
5166 if (bitmap_d[idx3] & val3) collisions++;
5167
5168 bitmap_a[idx0] |= val0;
5169 bitmap_b[idx1] |= val1;
5170 bitmap_c[idx2] |= val2;
5171 bitmap_d[idx3] |= val3;
5172
5173 if (collisions >= collisions_max) return 0x7fffffff;
5174 }
5175
5176 return collisions;
5177 }
5178
5179 /**
5180 * main
5181 */
5182
5183 int main (int argc, char **argv)
5184 {
5185 /**
5186 * To help users a bit
5187 */
5188
5189 char *compute = getenv ("COMPUTE");
5190
5191 if (compute)
5192 {
5193 static char display[100];
5194
5195 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5196
5197 putenv (display);
5198 }
5199 else
5200 {
5201 if (getenv ("DISPLAY") == NULL)
5202 putenv ((char *) "DISPLAY=:0");
5203 }
5204
5205 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5206 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5207
5208 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5209 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5210
5211 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5212 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5213
5214 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5215 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5216
5217 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5218 putenv ((char *) "POCL_KERNEL_CACHE=0");
5219
5220 /**
5221 * Real init
5222 */
5223
5224 memset (&data, 0, sizeof (hc_global_data_t));
5225
5226 time_t proc_start;
5227
5228 time (&proc_start);
5229
5230 data.proc_start = proc_start;
5231
5232 int myargc = argc;
5233 char **myargv = argv;
5234
5235 hc_thread_mutex_init (mux_dispatcher);
5236 hc_thread_mutex_init (mux_counter);
5237 hc_thread_mutex_init (mux_display);
5238 hc_thread_mutex_init (mux_adl);
5239
5240 /**
5241 * commandline parameters
5242 */
5243
5244 uint usage = USAGE;
5245 uint version = VERSION;
5246 uint quiet = QUIET;
5247 uint benchmark = BENCHMARK;
5248 uint show = SHOW;
5249 uint left = LEFT;
5250 uint username = USERNAME;
5251 uint remove = REMOVE;
5252 uint remove_timer = REMOVE_TIMER;
5253 u64 skip = SKIP;
5254 u64 limit = LIMIT;
5255 uint keyspace = KEYSPACE;
5256 uint potfile_disable = POTFILE_DISABLE;
5257 char *potfile_path = NULL;
5258 uint debug_mode = DEBUG_MODE;
5259 char *debug_file = NULL;
5260 char *induction_dir = NULL;
5261 char *outfile_check_dir = NULL;
5262 uint force = FORCE;
5263 uint runtime = RUNTIME;
5264 uint hash_mode = HASH_MODE;
5265 uint attack_mode = ATTACK_MODE;
5266 uint markov_disable = MARKOV_DISABLE;
5267 uint markov_classic = MARKOV_CLASSIC;
5268 uint markov_threshold = MARKOV_THRESHOLD;
5269 char *markov_hcstat = NULL;
5270 char *outfile = NULL;
5271 uint outfile_format = OUTFILE_FORMAT;
5272 uint outfile_autohex = OUTFILE_AUTOHEX;
5273 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5274 uint restore = RESTORE;
5275 uint restore_timer = RESTORE_TIMER;
5276 uint restore_disable = RESTORE_DISABLE;
5277 uint status = STATUS;
5278 uint status_timer = STATUS_TIMER;
5279 uint status_automat = STATUS_AUTOMAT;
5280 uint loopback = LOOPBACK;
5281 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5282 char *session = NULL;
5283 uint hex_charset = HEX_CHARSET;
5284 uint hex_salt = HEX_SALT;
5285 uint hex_wordlist = HEX_WORDLIST;
5286 uint rp_gen = RP_GEN;
5287 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5288 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5289 uint rp_gen_seed = RP_GEN_SEED;
5290 char *rule_buf_l = (char *) RULE_BUF_L;
5291 char *rule_buf_r = (char *) RULE_BUF_R;
5292 uint increment = INCREMENT;
5293 uint increment_min = INCREMENT_MIN;
5294 uint increment_max = INCREMENT_MAX;
5295 char *cpu_affinity = NULL;
5296 OCL_PTR *ocl = NULL;
5297 char *opencl_devices = NULL;
5298 char *opencl_platforms = NULL;
5299 char *opencl_device_types = NULL;
5300 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5301 char *truecrypt_keyfiles = NULL;
5302 uint workload_profile = WORKLOAD_PROFILE;
5303 uint kernel_accel = KERNEL_ACCEL;
5304 uint kernel_loops = KERNEL_LOOPS;
5305 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5306 #ifdef HAVE_HWMON
5307 uint gpu_temp_abort = GPU_TEMP_ABORT;
5308 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5309 #ifdef HAVE_ADL
5310 uint powertune_enable = POWERTUNE_ENABLE;
5311 #endif
5312 #endif
5313 uint logfile_disable = LOGFILE_DISABLE;
5314 uint segment_size = SEGMENT_SIZE;
5315 uint scrypt_tmto = SCRYPT_TMTO;
5316 char separator = SEPARATOR;
5317 uint bitmap_min = BITMAP_MIN;
5318 uint bitmap_max = BITMAP_MAX;
5319 char *custom_charset_1 = NULL;
5320 char *custom_charset_2 = NULL;
5321 char *custom_charset_3 = NULL;
5322 char *custom_charset_4 = NULL;
5323
5324 #define IDX_HELP 'h'
5325 #define IDX_VERSION 'V'
5326 #define IDX_VERSION_LOWER 'v'
5327 #define IDX_QUIET 0xff02
5328 #define IDX_SHOW 0xff03
5329 #define IDX_LEFT 0xff04
5330 #define IDX_REMOVE 0xff05
5331 #define IDX_REMOVE_TIMER 0xff37
5332 #define IDX_SKIP 's'
5333 #define IDX_LIMIT 'l'
5334 #define IDX_KEYSPACE 0xff35
5335 #define IDX_POTFILE_DISABLE 0xff06
5336 #define IDX_POTFILE_PATH 0xffe0
5337 #define IDX_DEBUG_MODE 0xff43
5338 #define IDX_DEBUG_FILE 0xff44
5339 #define IDX_INDUCTION_DIR 0xff46
5340 #define IDX_OUTFILE_CHECK_DIR 0xff47
5341 #define IDX_USERNAME 0xff07
5342 #define IDX_FORCE 0xff08
5343 #define IDX_RUNTIME 0xff09
5344 #define IDX_BENCHMARK 'b'
5345 #define IDX_HASH_MODE 'm'
5346 #define IDX_ATTACK_MODE 'a'
5347 #define IDX_RP_FILE 'r'
5348 #define IDX_RP_GEN 'g'
5349 #define IDX_RP_GEN_FUNC_MIN 0xff10
5350 #define IDX_RP_GEN_FUNC_MAX 0xff11
5351 #define IDX_RP_GEN_SEED 0xff34
5352 #define IDX_RULE_BUF_L 'j'
5353 #define IDX_RULE_BUF_R 'k'
5354 #define IDX_INCREMENT 'i'
5355 #define IDX_INCREMENT_MIN 0xff12
5356 #define IDX_INCREMENT_MAX 0xff13
5357 #define IDX_OUTFILE 'o'
5358 #define IDX_OUTFILE_FORMAT 0xff14
5359 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5360 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5361 #define IDX_RESTORE 0xff15
5362 #define IDX_RESTORE_DISABLE 0xff27
5363 #define IDX_STATUS 0xff17
5364 #define IDX_STATUS_TIMER 0xff18
5365 #define IDX_STATUS_AUTOMAT 0xff50
5366 #define IDX_LOOPBACK 0xff38
5367 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5368 #define IDX_SESSION 0xff19
5369 #define IDX_HEX_CHARSET 0xff20
5370 #define IDX_HEX_SALT 0xff21
5371 #define IDX_HEX_WORDLIST 0xff40
5372 #define IDX_MARKOV_DISABLE 0xff22
5373 #define IDX_MARKOV_CLASSIC 0xff23
5374 #define IDX_MARKOV_THRESHOLD 't'
5375 #define IDX_MARKOV_HCSTAT 0xff24
5376 #define IDX_CPU_AFFINITY 0xff25
5377 #define IDX_OPENCL_DEVICES 'd'
5378 #define IDX_OPENCL_PLATFORMS 0xff72
5379 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5380 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5381 #define IDX_WORKLOAD_PROFILE 'w'
5382 #define IDX_KERNEL_ACCEL 'n'
5383 #define IDX_KERNEL_LOOPS 'u'
5384 #define IDX_GPU_TEMP_DISABLE 0xff29
5385 #define IDX_GPU_TEMP_ABORT 0xff30
5386 #define IDX_GPU_TEMP_RETAIN 0xff31
5387 #define IDX_POWERTUNE_ENABLE 0xff41
5388 #define IDX_LOGFILE_DISABLE 0xff51
5389 #define IDX_TRUECRYPT_KEYFILES 0xff52
5390 #define IDX_SCRYPT_TMTO 0xff61
5391 #define IDX_SEGMENT_SIZE 'c'
5392 #define IDX_SEPARATOR 'p'
5393 #define IDX_BITMAP_MIN 0xff70
5394 #define IDX_BITMAP_MAX 0xff71
5395 #define IDX_CUSTOM_CHARSET_1 '1'
5396 #define IDX_CUSTOM_CHARSET_2 '2'
5397 #define IDX_CUSTOM_CHARSET_3 '3'
5398 #define IDX_CUSTOM_CHARSET_4 '4'
5399
5400 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5401
5402 struct option long_options[] =
5403 {
5404 {"help", no_argument, 0, IDX_HELP},
5405 {"version", no_argument, 0, IDX_VERSION},
5406 {"quiet", no_argument, 0, IDX_QUIET},
5407 {"show", no_argument, 0, IDX_SHOW},
5408 {"left", no_argument, 0, IDX_LEFT},
5409 {"username", no_argument, 0, IDX_USERNAME},
5410 {"remove", no_argument, 0, IDX_REMOVE},
5411 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5412 {"skip", required_argument, 0, IDX_SKIP},
5413 {"limit", required_argument, 0, IDX_LIMIT},
5414 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5415 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5416 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5417 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5418 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5419 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5420 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5421 {"force", no_argument, 0, IDX_FORCE},
5422 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5423 {"restore", no_argument, 0, IDX_RESTORE},
5424 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5425 {"status", no_argument, 0, IDX_STATUS},
5426 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5427 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5428 {"loopback", no_argument, 0, IDX_LOOPBACK},
5429 {"weak-hash-threshold",
5430 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5431 {"session", required_argument, 0, IDX_SESSION},
5432 {"runtime", required_argument, 0, IDX_RUNTIME},
5433 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5434 {"generate-rules-func-min",
5435 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5436 {"generate-rules-func-max",
5437 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5438 {"generate-rules-seed",
5439 required_argument, 0, IDX_RP_GEN_SEED},
5440 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5441 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5442 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5443 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5444 {"rules-file", required_argument, 0, IDX_RP_FILE},
5445 {"outfile", required_argument, 0, IDX_OUTFILE},
5446 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5447 {"outfile-autohex-disable",
5448 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5449 {"outfile-check-timer",
5450 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5451 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5452 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5453 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5454 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5455 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5456 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5457 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5458 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5459 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5460 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5461 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5462 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5463 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5464 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5465 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5466 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5467 #ifdef HAVE_HWMON
5468 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5469 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5470 #ifdef HAVE_ADL
5471 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5472 #endif
5473 #endif // HAVE_HWMON
5474 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5475 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5476 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5477 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5478 // deprecated
5479 {"seperator", required_argument, 0, IDX_SEPARATOR},
5480 {"separator", required_argument, 0, IDX_SEPARATOR},
5481 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5482 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5483 {"increment", no_argument, 0, IDX_INCREMENT},
5484 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5485 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5486 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5487 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5488 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5489 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5490
5491 {0, 0, 0, 0}
5492 };
5493
5494 uint rp_files_cnt = 0;
5495
5496 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5497
5498 int option_index = 0;
5499 int c = -1;
5500
5501 optind = 1;
5502 optopt = 0;
5503
5504 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5505 {
5506 switch (c)
5507 {
5508 case IDX_HELP: usage = 1; break;
5509 case IDX_VERSION:
5510 case IDX_VERSION_LOWER: version = 1; break;
5511 case IDX_RESTORE: restore = 1; break;
5512 case IDX_SESSION: session = optarg; break;
5513 case IDX_SHOW: show = 1; break;
5514 case IDX_LEFT: left = 1; break;
5515 case '?': return (-1);
5516 }
5517 }
5518
5519 if (optopt != 0)
5520 {
5521 log_error ("ERROR: Invalid argument specified");
5522
5523 return (-1);
5524 }
5525
5526 /**
5527 * exit functions
5528 */
5529
5530 if (version)
5531 {
5532 log_info ("%s", VERSION_TAG);
5533
5534 return (0);
5535 }
5536
5537 if (usage)
5538 {
5539 usage_big_print (PROGNAME);
5540
5541 return (0);
5542 }
5543
5544 /**
5545 * session needs to be set, always!
5546 */
5547
5548 if (session == NULL) session = (char *) PROGNAME;
5549
5550 /**
5551 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
5552 */
5553
5554 char *exec_path = get_exec_path ();
5555
5556 #ifdef LINUX
5557
5558 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5559 char *resolved_exec_path = realpath (exec_path, NULL);
5560
5561 char *install_dir = get_install_dir (resolved_exec_path);
5562 char *profile_dir = NULL;
5563 char *session_dir = NULL;
5564 char *shared_dir = NULL;
5565
5566 if (strcmp (install_dir, resolved_install_folder) == 0)
5567 {
5568 struct passwd *pw = getpwuid (getuid ());
5569
5570 const char *homedir = pw->pw_dir;
5571
5572 profile_dir = get_profile_dir (homedir);
5573 session_dir = get_session_dir (profile_dir);
5574 shared_dir = strdup (SHARED_FOLDER);
5575
5576 mkdir (profile_dir, 0700);
5577 mkdir (session_dir, 0700);
5578 }
5579 else
5580 {
5581 profile_dir = install_dir;
5582 session_dir = install_dir;
5583 shared_dir = install_dir;
5584 }
5585
5586 myfree (resolved_install_folder);
5587 myfree (resolved_exec_path);
5588
5589 #else
5590
5591 char *install_dir = get_install_dir (exec_path);
5592 char *profile_dir = install_dir;
5593 char *session_dir = install_dir;
5594 char *shared_dir = install_dir;
5595
5596 #endif
5597
5598 data.install_dir = install_dir;
5599 data.profile_dir = profile_dir;
5600 data.session_dir = session_dir;
5601 data.shared_dir = shared_dir;
5602
5603 myfree (exec_path);
5604
5605 /**
5606 * kernel cache, we need to make sure folder exist
5607 */
5608
5609 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5610
5611 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5612
5613 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5614
5615 mkdir (kernels_folder, 0700);
5616
5617 myfree (kernels_folder);
5618
5619 /**
5620 * session
5621 */
5622
5623 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5624
5625 data.session = session;
5626
5627 char *eff_restore_file = (char *) mymalloc (session_size);
5628 char *new_restore_file = (char *) mymalloc (session_size);
5629
5630 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5631 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5632
5633 data.eff_restore_file = eff_restore_file;
5634 data.new_restore_file = new_restore_file;
5635
5636 if (((show == 1) || (left == 1)) && (restore == 1))
5637 {
5638 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5639 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5640
5641 return (-1);
5642 }
5643
5644 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
5645 if ((show == 1) || (left == 1))
5646 {
5647 restore_disable = 1;
5648
5649 restore = 0;
5650 }
5651
5652 data.restore_disable = restore_disable;
5653
5654 restore_data_t *rd = init_restore (argc, argv);
5655
5656 data.rd = rd;
5657
5658 /**
5659 * restore file
5660 */
5661
5662 if (restore == 1)
5663 {
5664 read_restore (eff_restore_file, rd);
5665
5666 if (rd->version_bin < RESTORE_MIN)
5667 {
5668 log_error ("ERROR: Incompatible restore-file version");
5669
5670 return (-1);
5671 }
5672
5673 myargc = rd->argc;
5674 myargv = rd->argv;
5675
5676 #ifdef _POSIX
5677 rd->pid = getpid ();
5678 #elif _WIN
5679 rd->pid = GetCurrentProcessId ();
5680 #endif
5681 }
5682
5683 uint hash_mode_chgd = 0;
5684 uint runtime_chgd = 0;
5685 uint kernel_loops_chgd = 0;
5686 uint kernel_accel_chgd = 0;
5687 uint attack_mode_chgd = 0;
5688 uint outfile_format_chgd = 0;
5689 uint rp_gen_seed_chgd = 0;
5690 uint remove_timer_chgd = 0;
5691 uint increment_min_chgd = 0;
5692 uint increment_max_chgd = 0;
5693 uint workload_profile_chgd = 0;
5694 uint opencl_vector_width_chgd = 0;
5695
5696 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5697 uint gpu_temp_retain_chgd = 0;
5698 uint gpu_temp_abort_chgd = 0;
5699 #endif
5700
5701 optind = 1;
5702 optopt = 0;
5703 option_index = 0;
5704
5705 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5706 {
5707 switch (c)
5708 {
5709 //case IDX_HELP: usage = 1; break;
5710 //case IDX_VERSION: version = 1; break;
5711 //case IDX_RESTORE: restore = 1; break;
5712 case IDX_QUIET: quiet = 1; break;
5713 //case IDX_SHOW: show = 1; break;
5714 case IDX_SHOW: break;
5715 //case IDX_LEFT: left = 1; break;
5716 case IDX_LEFT: break;
5717 case IDX_USERNAME: username = 1; break;
5718 case IDX_REMOVE: remove = 1; break;
5719 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5720 remove_timer_chgd = 1; break;
5721 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5722 case IDX_POTFILE_PATH: potfile_path = optarg; break;
5723 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5724 case IDX_DEBUG_FILE: debug_file = optarg; break;
5725 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5726 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5727 case IDX_FORCE: force = 1; break;
5728 case IDX_SKIP: skip = atoll (optarg); break;
5729 case IDX_LIMIT: limit = atoll (optarg); break;
5730 case IDX_KEYSPACE: keyspace = 1; break;
5731 case IDX_BENCHMARK: benchmark = 1; break;
5732 case IDX_RESTORE: break;
5733 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5734 case IDX_STATUS: status = 1; break;
5735 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5736 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5737 case IDX_LOOPBACK: loopback = 1; break;
5738 case IDX_WEAK_HASH_THRESHOLD:
5739 weak_hash_threshold = atoi (optarg); break;
5740 //case IDX_SESSION: session = optarg; break;
5741 case IDX_SESSION: break;
5742 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5743 hash_mode_chgd = 1; break;
5744 case IDX_RUNTIME: runtime = atoi (optarg);
5745 runtime_chgd = 1; break;
5746 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5747 attack_mode_chgd = 1; break;
5748 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5749 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5750 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5751 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5752 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5753 rp_gen_seed_chgd = 1; break;
5754 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5755 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5756 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5757 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5758 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5759 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5760 case IDX_OUTFILE: outfile = optarg; break;
5761 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5762 outfile_format_chgd = 1; break;
5763 case IDX_OUTFILE_AUTOHEX_DISABLE:
5764 outfile_autohex = 0; break;
5765 case IDX_OUTFILE_CHECK_TIMER:
5766 outfile_check_timer = atoi (optarg); break;
5767 case IDX_HEX_CHARSET: hex_charset = 1; break;
5768 case IDX_HEX_SALT: hex_salt = 1; break;
5769 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5770 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5771 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5772 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5773 case IDX_OPENCL_DEVICE_TYPES:
5774 opencl_device_types = optarg; break;
5775 case IDX_OPENCL_VECTOR_WIDTH:
5776 opencl_vector_width = atoi (optarg);
5777 opencl_vector_width_chgd = 1; break;
5778 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
5779 workload_profile_chgd = 1; break;
5780 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5781 kernel_accel_chgd = 1; break;
5782 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5783 kernel_loops_chgd = 1; break;
5784 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5785 #ifdef HAVE_HWMON
5786 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5787 #ifdef HAVE_ADL
5788 gpu_temp_abort_chgd = 1;
5789 #endif
5790 break;
5791 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5792 #ifdef HAVE_ADL
5793 gpu_temp_retain_chgd = 1;
5794 #endif
5795 break;
5796 #ifdef HAVE_ADL
5797 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5798 #endif
5799 #endif // HAVE_HWMON
5800 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5801 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5802 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5803 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5804 case IDX_SEPARATOR: separator = optarg[0]; break;
5805 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5806 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5807 case IDX_INCREMENT: increment = 1; break;
5808 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5809 increment_min_chgd = 1; break;
5810 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5811 increment_max_chgd = 1; break;
5812 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5813 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5814 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5815 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5816
5817 default:
5818 log_error ("ERROR: Invalid argument specified");
5819 return (-1);
5820 }
5821 }
5822
5823 if (optopt != 0)
5824 {
5825 log_error ("ERROR: Invalid argument specified");
5826
5827 return (-1);
5828 }
5829
5830 /**
5831 * Inform user things getting started,
5832 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5833 * - we do not need to check algorithm_pos
5834 */
5835
5836 if (quiet == 0)
5837 {
5838 if (benchmark == 1)
5839 {
5840 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
5841
5842 log_info ("");
5843 }
5844 else if (restore == 1)
5845 {
5846 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
5847
5848 log_info ("");
5849 }
5850 else
5851 {
5852 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
5853
5854 log_info ("");
5855 }
5856 }
5857
5858 /**
5859 * sanity check
5860 */
5861
5862 if (attack_mode > 7)
5863 {
5864 log_error ("ERROR: Invalid attack-mode specified");
5865
5866 return (-1);
5867 }
5868
5869 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5870 {
5871 log_error ("ERROR: Invalid runtime specified");
5872
5873 return (-1);
5874 }
5875
5876 if (hash_mode_chgd && hash_mode > 13500) // just added to remove compiler warnings for hash_mode_chgd
5877 {
5878 log_error ("ERROR: Invalid hash-type specified");
5879
5880 return (-1);
5881 }
5882
5883 // renamed hash modes
5884
5885 if (hash_mode_chgd)
5886 {
5887 int n = -1;
5888
5889 switch (hash_mode)
5890 {
5891 case 123: n = 124;
5892 break;
5893 }
5894
5895 if (n >= 0)
5896 {
5897 log_error ("Old -m specified, use -m %d instead", n);
5898
5899 return (-1);
5900 }
5901 }
5902
5903 if (username == 1)
5904 {
5905 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
5906 {
5907 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5908
5909 return (-1);
5910 }
5911 }
5912
5913 if (outfile_format > 16)
5914 {
5915 log_error ("ERROR: Invalid outfile-format specified");
5916
5917 return (-1);
5918 }
5919
5920 if (left == 1)
5921 {
5922 if (outfile_format_chgd == 1)
5923 {
5924 if (outfile_format > 1)
5925 {
5926 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
5927
5928 return (-1);
5929 }
5930 }
5931 else
5932 {
5933 outfile_format = OUTFILE_FMT_HASH;
5934 }
5935 }
5936
5937 if (show == 1)
5938 {
5939 if (outfile_format_chgd == 1)
5940 {
5941 if ((outfile_format > 7) && (outfile_format < 16))
5942 {
5943 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
5944
5945 return (-1);
5946 }
5947 }
5948 }
5949
5950 if (increment_min < INCREMENT_MIN)
5951 {
5952 log_error ("ERROR: Invalid increment-min specified");
5953
5954 return (-1);
5955 }
5956
5957 if (increment_max > INCREMENT_MAX)
5958 {
5959 log_error ("ERROR: Invalid increment-max specified");
5960
5961 return (-1);
5962 }
5963
5964 if (increment_min > increment_max)
5965 {
5966 log_error ("ERROR: Invalid increment-min specified");
5967
5968 return (-1);
5969 }
5970
5971 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
5972 {
5973 log_error ("ERROR: increment is not allowed in attack-mode 0");
5974
5975 return (-1);
5976 }
5977
5978 if ((increment == 0) && (increment_min_chgd == 1))
5979 {
5980 log_error ("ERROR: increment-min is only supported together with increment switch");
5981
5982 return (-1);
5983 }
5984
5985 if ((increment == 0) && (increment_max_chgd == 1))
5986 {
5987 log_error ("ERROR: increment-max is only supported together with increment switch");
5988
5989 return (-1);
5990 }
5991
5992 if (rp_files_cnt && rp_gen)
5993 {
5994 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
5995
5996 return (-1);
5997 }
5998
5999 if (rp_files_cnt || rp_gen)
6000 {
6001 if (attack_mode != ATTACK_MODE_STRAIGHT)
6002 {
6003 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6004
6005 return (-1);
6006 }
6007 }
6008
6009 if (rp_gen_func_min > rp_gen_func_max)
6010 {
6011 log_error ("ERROR: Invalid rp-gen-func-min specified");
6012
6013 return (-1);
6014 }
6015
6016 if (kernel_accel_chgd == 1)
6017 {
6018 if (kernel_accel < 1)
6019 {
6020 log_error ("ERROR: Invalid kernel-accel specified");
6021
6022 return (-1);
6023 }
6024
6025 if (kernel_accel > 1024)
6026 {
6027 log_error ("ERROR: Invalid kernel-accel specified");
6028
6029 return (-1);
6030 }
6031 }
6032
6033 if (kernel_loops_chgd == 1)
6034 {
6035 if (kernel_loops < 1)
6036 {
6037 log_error ("ERROR: Invalid kernel-loops specified");
6038
6039 return (-1);
6040 }
6041
6042 if (kernel_loops > 1024)
6043 {
6044 log_error ("ERROR: Invalid kernel-loops specified");
6045
6046 return (-1);
6047 }
6048 }
6049
6050 if ((workload_profile < 1) || (workload_profile > 3))
6051 {
6052 log_error ("ERROR: workload-profile %i not available", workload_profile);
6053
6054 return (-1);
6055 }
6056
6057 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6058 {
6059 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6060
6061 return (-1);
6062 }
6063
6064 if (show == 1 || left == 1)
6065 {
6066 attack_mode = ATTACK_MODE_NONE;
6067
6068 if (remove == 1)
6069 {
6070 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6071
6072 return (-1);
6073 }
6074
6075 if (potfile_disable == 1)
6076 {
6077 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6078
6079 return (-1);
6080 }
6081 }
6082
6083 uint attack_kern = ATTACK_KERN_NONE;
6084
6085 switch (attack_mode)
6086 {
6087 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6088 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6089 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6090 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6091 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6092 }
6093
6094 if (benchmark == 0)
6095 {
6096 if (keyspace == 1)
6097 {
6098 int num_additional_params = 1;
6099
6100 if (attack_kern == ATTACK_KERN_COMBI)
6101 {
6102 num_additional_params = 2;
6103 }
6104
6105 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6106
6107 if (keyspace_wordlist_specified == 0) optind--;
6108 }
6109
6110 if (attack_kern == ATTACK_KERN_NONE)
6111 {
6112 if ((optind + 1) != myargc)
6113 {
6114 usage_mini_print (myargv[0]);
6115
6116 return (-1);
6117 }
6118 }
6119 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6120 {
6121 if ((optind + 1) > myargc)
6122 {
6123 usage_mini_print (myargv[0]);
6124
6125 return (-1);
6126 }
6127 }
6128 else if (attack_kern == ATTACK_KERN_COMBI)
6129 {
6130 if ((optind + 3) != myargc)
6131 {
6132 usage_mini_print (myargv[0]);
6133
6134 return (-1);
6135 }
6136 }
6137 else if (attack_kern == ATTACK_KERN_BF)
6138 {
6139 if ((optind + 1) > myargc)
6140 {
6141 usage_mini_print (myargv[0]);
6142
6143 return (-1);
6144 }
6145 }
6146 else
6147 {
6148 usage_mini_print (myargv[0]);
6149
6150 return (-1);
6151 }
6152 }
6153 else
6154 {
6155 if (myargv[optind] != 0)
6156 {
6157 log_error ("ERROR: Invalid argument for benchmark mode specified");
6158
6159 return (-1);
6160 }
6161
6162 if (attack_mode_chgd == 1)
6163 {
6164 if (attack_mode != ATTACK_MODE_BF)
6165 {
6166 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6167
6168 return (-1);
6169 }
6170 }
6171 }
6172
6173 if (skip != 0 && limit != 0)
6174 {
6175 limit += skip;
6176 }
6177
6178 if (keyspace == 1)
6179 {
6180 if (show == 1)
6181 {
6182 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6183
6184 return (-1);
6185 }
6186 else if (left == 1)
6187 {
6188 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6189
6190 return (-1);
6191 }
6192
6193 potfile_disable = 1;
6194
6195 restore_disable = 1;
6196
6197 restore = 0;
6198
6199 weak_hash_threshold = 0;
6200
6201 quiet = 1;
6202 }
6203
6204 if (remove_timer_chgd == 1)
6205 {
6206 if (remove == 0)
6207 {
6208 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6209
6210 return (-1);
6211 }
6212
6213 if (remove_timer < 1)
6214 {
6215 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6216
6217 return (-1);
6218 }
6219 }
6220
6221 if (loopback == 1)
6222 {
6223 if (attack_mode == ATTACK_MODE_STRAIGHT)
6224 {
6225 if ((rp_files_cnt == 0) && (rp_gen == 0))
6226 {
6227 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6228
6229 return (-1);
6230 }
6231 }
6232 else
6233 {
6234 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6235
6236 return (-1);
6237 }
6238 }
6239
6240 if (debug_mode > 0)
6241 {
6242 if (attack_mode != ATTACK_MODE_STRAIGHT)
6243 {
6244 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6245
6246 return (-1);
6247 }
6248
6249 if ((rp_files_cnt == 0) && (rp_gen == 0))
6250 {
6251 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6252
6253 return (-1);
6254 }
6255 }
6256
6257 if (debug_mode > 4)
6258 {
6259 log_error ("ERROR: Invalid debug-mode specified");
6260
6261 return (-1);
6262 }
6263
6264 if (debug_file != NULL)
6265 {
6266 if (debug_mode < 1)
6267 {
6268 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6269
6270 return (-1);
6271 }
6272 }
6273
6274 if (induction_dir != NULL)
6275 {
6276 if (attack_mode == ATTACK_MODE_BF)
6277 {
6278 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6279
6280 return (-1);
6281 }
6282 }
6283
6284 if (attack_mode != ATTACK_MODE_STRAIGHT)
6285 {
6286 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6287 {
6288 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6289
6290 return (-1);
6291 }
6292
6293 weak_hash_threshold = 0;
6294 }
6295
6296 /**
6297 * induction directory
6298 */
6299
6300 char *induction_directory = NULL;
6301
6302 if (attack_mode != ATTACK_MODE_BF)
6303 {
6304 if (induction_dir == NULL)
6305 {
6306 induction_directory = (char *) mymalloc (session_size);
6307
6308 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6309
6310 // create induction folder if it does not already exist
6311
6312 if (keyspace == 0)
6313 {
6314 if (rmdir (induction_directory) == -1)
6315 {
6316 if (errno == ENOENT)
6317 {
6318 // good, we can ignore
6319 }
6320 else if (errno == ENOTEMPTY)
6321 {
6322 char *induction_directory_mv = (char *) mymalloc (session_size);
6323
6324 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6325
6326 if (rename (induction_directory, induction_directory_mv) != 0)
6327 {
6328 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6329
6330 return (-1);
6331 }
6332 }
6333 else
6334 {
6335 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6336
6337 return (-1);
6338 }
6339 }
6340
6341 if (mkdir (induction_directory, 0700) == -1)
6342 {
6343 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6344
6345 return (-1);
6346 }
6347 }
6348 }
6349 else
6350 {
6351 induction_directory = induction_dir;
6352 }
6353 }
6354
6355 data.induction_directory = induction_directory;
6356
6357 /**
6358 * loopback
6359 */
6360
6361 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6362
6363 char *loopback_file = (char *) mymalloc (loopback_size);
6364
6365 /**
6366 * tuning db
6367 */
6368
6369 char tuning_db_file[256] = { 0 };
6370
6371 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6372
6373 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6374
6375 /**
6376 * outfile-check directory
6377 */
6378
6379 char *outfile_check_directory = NULL;
6380
6381 if (outfile_check_dir == NULL)
6382 {
6383 outfile_check_directory = (char *) mymalloc (session_size);
6384
6385 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6386 }
6387 else
6388 {
6389 outfile_check_directory = outfile_check_dir;
6390 }
6391
6392 data.outfile_check_directory = outfile_check_directory;
6393
6394 if (keyspace == 0)
6395 {
6396 struct stat outfile_check_stat;
6397
6398 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6399 {
6400 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6401
6402 if (is_dir == 0)
6403 {
6404 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6405
6406 return (-1);
6407 }
6408 }
6409 else if (outfile_check_dir == NULL)
6410 {
6411 if (mkdir (outfile_check_directory, 0700) == -1)
6412 {
6413 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6414
6415 return (-1);
6416 }
6417 }
6418 }
6419
6420 /**
6421 * special other stuff
6422 */
6423
6424 if (hash_mode == 9710)
6425 {
6426 outfile_format = 5;
6427 outfile_format_chgd = 1;
6428 }
6429
6430 if (hash_mode == 9810)
6431 {
6432 outfile_format = 5;
6433 outfile_format_chgd = 1;
6434 }
6435
6436 if (hash_mode == 10410)
6437 {
6438 outfile_format = 5;
6439 outfile_format_chgd = 1;
6440 }
6441
6442 /**
6443 * store stuff
6444 */
6445
6446 data.hash_mode = hash_mode;
6447 data.restore = restore;
6448 data.restore_timer = restore_timer;
6449 data.restore_disable = restore_disable;
6450 data.status = status;
6451 data.status_timer = status_timer;
6452 data.status_automat = status_automat;
6453 data.loopback = loopback;
6454 data.runtime = runtime;
6455 data.remove = remove;
6456 data.remove_timer = remove_timer;
6457 data.debug_mode = debug_mode;
6458 data.debug_file = debug_file;
6459 data.username = username;
6460 data.quiet = quiet;
6461 data.outfile = outfile;
6462 data.outfile_format = outfile_format;
6463 data.outfile_autohex = outfile_autohex;
6464 data.hex_charset = hex_charset;
6465 data.hex_salt = hex_salt;
6466 data.hex_wordlist = hex_wordlist;
6467 data.separator = separator;
6468 data.rp_files = rp_files;
6469 data.rp_files_cnt = rp_files_cnt;
6470 data.rp_gen = rp_gen;
6471 data.rp_gen_seed = rp_gen_seed;
6472 data.force = force;
6473 data.benchmark = benchmark;
6474 data.skip = skip;
6475 data.limit = limit;
6476 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6477 data.powertune_enable = powertune_enable;
6478 #endif
6479 data.logfile_disable = logfile_disable;
6480 data.truecrypt_keyfiles = truecrypt_keyfiles;
6481 data.scrypt_tmto = scrypt_tmto;
6482 data.workload_profile = workload_profile;
6483
6484 /**
6485 * cpu affinity
6486 */
6487
6488 if (cpu_affinity)
6489 {
6490 set_cpu_affinity (cpu_affinity);
6491 }
6492
6493 if (rp_gen_seed_chgd == 0)
6494 {
6495 srand (proc_start);
6496 }
6497 else
6498 {
6499 srand (rp_gen_seed);
6500 }
6501
6502 /**
6503 * logfile init
6504 */
6505
6506 if (logfile_disable == 0)
6507 {
6508 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6509
6510 char *logfile = (char *) mymalloc (logfile_size);
6511
6512 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6513
6514 data.logfile = logfile;
6515
6516 char *topid = logfile_generate_topid ();
6517
6518 data.topid = topid;
6519 }
6520
6521 // logfile_append() checks for logfile_disable internally to make it easier from here
6522
6523 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6524 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6525 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6526 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6527 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6528 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6529 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6530 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6531 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6532 #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));
6533
6534 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6535 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6536 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6537 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6538 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6539 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6540 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6541 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6542
6543 logfile_top_msg ("START");
6544
6545 logfile_top_uint (attack_mode);
6546 logfile_top_uint (attack_kern);
6547 logfile_top_uint (benchmark);
6548 logfile_top_uint (bitmap_min);
6549 logfile_top_uint (bitmap_max);
6550 logfile_top_uint (debug_mode);
6551 logfile_top_uint (force);
6552 logfile_top_uint (kernel_accel);
6553 logfile_top_uint (kernel_loops);
6554 logfile_top_uint (gpu_temp_disable);
6555 #ifdef HAVE_HWMON
6556 logfile_top_uint (gpu_temp_abort);
6557 logfile_top_uint (gpu_temp_retain);
6558 #endif
6559 logfile_top_uint (hash_mode);
6560 logfile_top_uint (hex_charset);
6561 logfile_top_uint (hex_salt);
6562 logfile_top_uint (hex_wordlist);
6563 logfile_top_uint (increment);
6564 logfile_top_uint (increment_max);
6565 logfile_top_uint (increment_min);
6566 logfile_top_uint (keyspace);
6567 logfile_top_uint (left);
6568 logfile_top_uint (logfile_disable);
6569 logfile_top_uint (loopback);
6570 logfile_top_uint (markov_classic);
6571 logfile_top_uint (markov_disable);
6572 logfile_top_uint (markov_threshold);
6573 logfile_top_uint (outfile_autohex);
6574 logfile_top_uint (outfile_check_timer);
6575 logfile_top_uint (outfile_format);
6576 logfile_top_uint (potfile_disable);
6577 logfile_top_string (potfile_path);
6578 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6579 logfile_top_uint (powertune_enable);
6580 #endif
6581 logfile_top_uint (scrypt_tmto);
6582 logfile_top_uint (quiet);
6583 logfile_top_uint (remove);
6584 logfile_top_uint (remove_timer);
6585 logfile_top_uint (restore);
6586 logfile_top_uint (restore_disable);
6587 logfile_top_uint (restore_timer);
6588 logfile_top_uint (rp_gen);
6589 logfile_top_uint (rp_gen_func_max);
6590 logfile_top_uint (rp_gen_func_min);
6591 logfile_top_uint (rp_gen_seed);
6592 logfile_top_uint (runtime);
6593 logfile_top_uint (segment_size);
6594 logfile_top_uint (show);
6595 logfile_top_uint (status);
6596 logfile_top_uint (status_automat);
6597 logfile_top_uint (status_timer);
6598 logfile_top_uint (usage);
6599 logfile_top_uint (username);
6600 logfile_top_uint (version);
6601 logfile_top_uint (weak_hash_threshold);
6602 logfile_top_uint (workload_profile);
6603 logfile_top_uint64 (limit);
6604 logfile_top_uint64 (skip);
6605 logfile_top_char (separator);
6606 logfile_top_string (cpu_affinity);
6607 logfile_top_string (custom_charset_1);
6608 logfile_top_string (custom_charset_2);
6609 logfile_top_string (custom_charset_3);
6610 logfile_top_string (custom_charset_4);
6611 logfile_top_string (debug_file);
6612 logfile_top_string (opencl_devices);
6613 logfile_top_string (opencl_platforms);
6614 logfile_top_string (opencl_device_types);
6615 logfile_top_uint (opencl_vector_width);
6616 logfile_top_string (induction_dir);
6617 logfile_top_string (markov_hcstat);
6618 logfile_top_string (outfile);
6619 logfile_top_string (outfile_check_dir);
6620 logfile_top_string (rule_buf_l);
6621 logfile_top_string (rule_buf_r);
6622 logfile_top_string (session);
6623 logfile_top_string (truecrypt_keyfiles);
6624
6625 /**
6626 * Init OpenCL library loader
6627 */
6628
6629 if (keyspace == 0)
6630 {
6631 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6632
6633 ocl_init (ocl);
6634
6635 data.ocl = ocl;
6636 }
6637
6638 /**
6639 * OpenCL platform selection
6640 */
6641
6642 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6643
6644 /**
6645 * OpenCL device selection
6646 */
6647
6648 u32 devices_filter = setup_devices_filter (opencl_devices);
6649
6650 /**
6651 * OpenCL device type selection
6652 */
6653
6654 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6655
6656 /**
6657 * benchmark
6658 */
6659
6660 if (benchmark == 1)
6661 {
6662 /**
6663 * disable useless stuff for benchmark
6664 */
6665
6666 status_timer = 0;
6667 restore_timer = 0;
6668 restore_disable = 1;
6669 potfile_disable = 1;
6670 weak_hash_threshold = 0;
6671 gpu_temp_disable = 1;
6672
6673 data.status_timer = status_timer;
6674 data.restore_timer = restore_timer;
6675 data.restore_disable = restore_disable;
6676
6677 /**
6678 * force attack mode to be bruteforce
6679 */
6680
6681 attack_mode = ATTACK_MODE_BF;
6682 attack_kern = ATTACK_KERN_BF;
6683
6684 if (workload_profile_chgd == 0)
6685 {
6686 workload_profile = 3;
6687
6688 data.workload_profile = workload_profile;
6689 }
6690 }
6691
6692 /**
6693 * config
6694 */
6695
6696 uint hash_type = 0;
6697 uint salt_type = 0;
6698 uint attack_exec = 0;
6699 uint opts_type = 0;
6700 uint kern_type = 0;
6701 uint dgst_size = 0;
6702 uint esalt_size = 0;
6703 uint opti_type = 0;
6704 uint dgst_pos0 = -1;
6705 uint dgst_pos1 = -1;
6706 uint dgst_pos2 = -1;
6707 uint dgst_pos3 = -1;
6708
6709 int (*parse_func) (char *, uint, hash_t *);
6710 int (*sort_by_digest) (const void *, const void *);
6711
6712 uint algorithm_pos = 0;
6713 uint algorithm_max = 1;
6714
6715 uint *algorithms = default_benchmark_algorithms;
6716
6717 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6718
6719 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6720 {
6721 /*
6722 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6723 * the following algos are skipped entirely
6724 */
6725
6726 if (algorithm_pos > 0)
6727 {
6728 local_free (rd);
6729
6730 rd = init_restore (argc, argv);
6731
6732 data.rd = rd;
6733 }
6734
6735 /**
6736 * update hash_mode in case of multihash benchmark
6737 */
6738
6739 if (benchmark == 1)
6740 {
6741 if (hash_mode_chgd == 0)
6742 {
6743 hash_mode = algorithms[algorithm_pos];
6744
6745 data.hash_mode = hash_mode;
6746 }
6747
6748 quiet = 1;
6749
6750 data.quiet = quiet;
6751 }
6752
6753 switch (hash_mode)
6754 {
6755 case 0: hash_type = HASH_TYPE_MD5;
6756 salt_type = SALT_TYPE_NONE;
6757 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6758 opts_type = OPTS_TYPE_PT_GENERATE_LE
6759 | OPTS_TYPE_PT_ADD80
6760 | OPTS_TYPE_PT_ADDBITS14;
6761 kern_type = KERN_TYPE_MD5;
6762 dgst_size = DGST_SIZE_4_4;
6763 parse_func = md5_parse_hash;
6764 sort_by_digest = sort_by_digest_4_4;
6765 opti_type = OPTI_TYPE_ZERO_BYTE
6766 | OPTI_TYPE_PRECOMPUTE_INIT
6767 | OPTI_TYPE_PRECOMPUTE_MERKLE
6768 | OPTI_TYPE_MEET_IN_MIDDLE
6769 | OPTI_TYPE_EARLY_SKIP
6770 | OPTI_TYPE_NOT_ITERATED
6771 | OPTI_TYPE_NOT_SALTED
6772 | OPTI_TYPE_RAW_HASH;
6773 dgst_pos0 = 0;
6774 dgst_pos1 = 3;
6775 dgst_pos2 = 2;
6776 dgst_pos3 = 1;
6777 break;
6778
6779 case 10: hash_type = HASH_TYPE_MD5;
6780 salt_type = SALT_TYPE_INTERN;
6781 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6782 opts_type = OPTS_TYPE_PT_GENERATE_LE
6783 | OPTS_TYPE_ST_ADD80
6784 | OPTS_TYPE_ST_ADDBITS14;
6785 kern_type = KERN_TYPE_MD5_PWSLT;
6786 dgst_size = DGST_SIZE_4_4;
6787 parse_func = md5s_parse_hash;
6788 sort_by_digest = sort_by_digest_4_4;
6789 opti_type = OPTI_TYPE_ZERO_BYTE
6790 | OPTI_TYPE_PRECOMPUTE_INIT
6791 | OPTI_TYPE_PRECOMPUTE_MERKLE
6792 | OPTI_TYPE_MEET_IN_MIDDLE
6793 | OPTI_TYPE_EARLY_SKIP
6794 | OPTI_TYPE_NOT_ITERATED
6795 | OPTI_TYPE_APPENDED_SALT
6796 | OPTI_TYPE_RAW_HASH;
6797 dgst_pos0 = 0;
6798 dgst_pos1 = 3;
6799 dgst_pos2 = 2;
6800 dgst_pos3 = 1;
6801 break;
6802
6803 case 11: hash_type = HASH_TYPE_MD5;
6804 salt_type = SALT_TYPE_INTERN;
6805 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6806 opts_type = OPTS_TYPE_PT_GENERATE_LE
6807 | OPTS_TYPE_ST_ADD80
6808 | OPTS_TYPE_ST_ADDBITS14;
6809 kern_type = KERN_TYPE_MD5_PWSLT;
6810 dgst_size = DGST_SIZE_4_4;
6811 parse_func = joomla_parse_hash;
6812 sort_by_digest = sort_by_digest_4_4;
6813 opti_type = OPTI_TYPE_ZERO_BYTE
6814 | OPTI_TYPE_PRECOMPUTE_INIT
6815 | OPTI_TYPE_PRECOMPUTE_MERKLE
6816 | OPTI_TYPE_MEET_IN_MIDDLE
6817 | OPTI_TYPE_EARLY_SKIP
6818 | OPTI_TYPE_NOT_ITERATED
6819 | OPTI_TYPE_APPENDED_SALT
6820 | OPTI_TYPE_RAW_HASH;
6821 dgst_pos0 = 0;
6822 dgst_pos1 = 3;
6823 dgst_pos2 = 2;
6824 dgst_pos3 = 1;
6825 break;
6826
6827 case 12: hash_type = HASH_TYPE_MD5;
6828 salt_type = SALT_TYPE_INTERN;
6829 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6830 opts_type = OPTS_TYPE_PT_GENERATE_LE
6831 | OPTS_TYPE_ST_ADD80
6832 | OPTS_TYPE_ST_ADDBITS14;
6833 kern_type = KERN_TYPE_MD5_PWSLT;
6834 dgst_size = DGST_SIZE_4_4;
6835 parse_func = postgresql_parse_hash;
6836 sort_by_digest = sort_by_digest_4_4;
6837 opti_type = OPTI_TYPE_ZERO_BYTE
6838 | OPTI_TYPE_PRECOMPUTE_INIT
6839 | OPTI_TYPE_PRECOMPUTE_MERKLE
6840 | OPTI_TYPE_MEET_IN_MIDDLE
6841 | OPTI_TYPE_EARLY_SKIP
6842 | OPTI_TYPE_NOT_ITERATED
6843 | OPTI_TYPE_APPENDED_SALT
6844 | OPTI_TYPE_RAW_HASH;
6845 dgst_pos0 = 0;
6846 dgst_pos1 = 3;
6847 dgst_pos2 = 2;
6848 dgst_pos3 = 1;
6849 break;
6850
6851 case 20: hash_type = HASH_TYPE_MD5;
6852 salt_type = SALT_TYPE_INTERN;
6853 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6854 opts_type = OPTS_TYPE_PT_GENERATE_LE
6855 | OPTS_TYPE_PT_ADD80
6856 | OPTS_TYPE_PT_ADDBITS14;
6857 kern_type = KERN_TYPE_MD5_SLTPW;
6858 dgst_size = DGST_SIZE_4_4;
6859 parse_func = md5s_parse_hash;
6860 sort_by_digest = sort_by_digest_4_4;
6861 opti_type = OPTI_TYPE_ZERO_BYTE
6862 | OPTI_TYPE_PRECOMPUTE_INIT
6863 | OPTI_TYPE_PRECOMPUTE_MERKLE
6864 | OPTI_TYPE_EARLY_SKIP
6865 | OPTI_TYPE_NOT_ITERATED
6866 | OPTI_TYPE_PREPENDED_SALT
6867 | OPTI_TYPE_RAW_HASH;
6868 dgst_pos0 = 0;
6869 dgst_pos1 = 3;
6870 dgst_pos2 = 2;
6871 dgst_pos3 = 1;
6872 break;
6873
6874 case 21: hash_type = HASH_TYPE_MD5;
6875 salt_type = SALT_TYPE_INTERN;
6876 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6877 opts_type = OPTS_TYPE_PT_GENERATE_LE
6878 | OPTS_TYPE_PT_ADD80
6879 | OPTS_TYPE_PT_ADDBITS14;
6880 kern_type = KERN_TYPE_MD5_SLTPW;
6881 dgst_size = DGST_SIZE_4_4;
6882 parse_func = osc_parse_hash;
6883 sort_by_digest = sort_by_digest_4_4;
6884 opti_type = OPTI_TYPE_ZERO_BYTE
6885 | OPTI_TYPE_PRECOMPUTE_INIT
6886 | OPTI_TYPE_PRECOMPUTE_MERKLE
6887 | OPTI_TYPE_EARLY_SKIP
6888 | OPTI_TYPE_NOT_ITERATED
6889 | OPTI_TYPE_PREPENDED_SALT
6890 | OPTI_TYPE_RAW_HASH;
6891 dgst_pos0 = 0;
6892 dgst_pos1 = 3;
6893 dgst_pos2 = 2;
6894 dgst_pos3 = 1;
6895 break;
6896
6897 case 22: hash_type = HASH_TYPE_MD5;
6898 salt_type = SALT_TYPE_EMBEDDED;
6899 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6900 opts_type = OPTS_TYPE_PT_GENERATE_LE
6901 | OPTS_TYPE_PT_ADD80
6902 | OPTS_TYPE_PT_ADDBITS14;
6903 kern_type = KERN_TYPE_MD5_SLTPW;
6904 dgst_size = DGST_SIZE_4_4;
6905 parse_func = netscreen_parse_hash;
6906 sort_by_digest = sort_by_digest_4_4;
6907 opti_type = OPTI_TYPE_ZERO_BYTE
6908 | OPTI_TYPE_PRECOMPUTE_INIT
6909 | OPTI_TYPE_PRECOMPUTE_MERKLE
6910 | OPTI_TYPE_EARLY_SKIP
6911 | OPTI_TYPE_NOT_ITERATED
6912 | OPTI_TYPE_PREPENDED_SALT
6913 | OPTI_TYPE_RAW_HASH;
6914 dgst_pos0 = 0;
6915 dgst_pos1 = 3;
6916 dgst_pos2 = 2;
6917 dgst_pos3 = 1;
6918 break;
6919
6920 case 23: hash_type = HASH_TYPE_MD5;
6921 salt_type = SALT_TYPE_EMBEDDED;
6922 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6923 opts_type = OPTS_TYPE_PT_GENERATE_LE
6924 | OPTS_TYPE_PT_ADD80
6925 | OPTS_TYPE_PT_ADDBITS14;
6926 kern_type = KERN_TYPE_MD5_SLTPW;
6927 dgst_size = DGST_SIZE_4_4;
6928 parse_func = skype_parse_hash;
6929 sort_by_digest = sort_by_digest_4_4;
6930 opti_type = OPTI_TYPE_ZERO_BYTE
6931 | OPTI_TYPE_PRECOMPUTE_INIT
6932 | OPTI_TYPE_PRECOMPUTE_MERKLE
6933 | OPTI_TYPE_EARLY_SKIP
6934 | OPTI_TYPE_NOT_ITERATED
6935 | OPTI_TYPE_PREPENDED_SALT
6936 | OPTI_TYPE_RAW_HASH;
6937 dgst_pos0 = 0;
6938 dgst_pos1 = 3;
6939 dgst_pos2 = 2;
6940 dgst_pos3 = 1;
6941 break;
6942
6943 case 30: hash_type = HASH_TYPE_MD5;
6944 salt_type = SALT_TYPE_INTERN;
6945 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6946 opts_type = OPTS_TYPE_PT_GENERATE_LE
6947 | OPTS_TYPE_PT_UNICODE
6948 | OPTS_TYPE_ST_ADD80
6949 | OPTS_TYPE_ST_ADDBITS14;
6950 kern_type = KERN_TYPE_MD5_PWUSLT;
6951 dgst_size = DGST_SIZE_4_4;
6952 parse_func = md5s_parse_hash;
6953 sort_by_digest = sort_by_digest_4_4;
6954 opti_type = OPTI_TYPE_ZERO_BYTE
6955 | OPTI_TYPE_PRECOMPUTE_INIT
6956 | OPTI_TYPE_PRECOMPUTE_MERKLE
6957 | OPTI_TYPE_MEET_IN_MIDDLE
6958 | OPTI_TYPE_EARLY_SKIP
6959 | OPTI_TYPE_NOT_ITERATED
6960 | OPTI_TYPE_APPENDED_SALT
6961 | OPTI_TYPE_RAW_HASH;
6962 dgst_pos0 = 0;
6963 dgst_pos1 = 3;
6964 dgst_pos2 = 2;
6965 dgst_pos3 = 1;
6966 break;
6967
6968 case 40: hash_type = HASH_TYPE_MD5;
6969 salt_type = SALT_TYPE_INTERN;
6970 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6971 opts_type = OPTS_TYPE_PT_GENERATE_LE
6972 | OPTS_TYPE_PT_ADD80
6973 | OPTS_TYPE_PT_ADDBITS14
6974 | OPTS_TYPE_PT_UNICODE;
6975 kern_type = KERN_TYPE_MD5_SLTPWU;
6976 dgst_size = DGST_SIZE_4_4;
6977 parse_func = md5s_parse_hash;
6978 sort_by_digest = sort_by_digest_4_4;
6979 opti_type = OPTI_TYPE_ZERO_BYTE
6980 | OPTI_TYPE_PRECOMPUTE_INIT
6981 | OPTI_TYPE_PRECOMPUTE_MERKLE
6982 | OPTI_TYPE_EARLY_SKIP
6983 | OPTI_TYPE_NOT_ITERATED
6984 | OPTI_TYPE_PREPENDED_SALT
6985 | OPTI_TYPE_RAW_HASH;
6986 dgst_pos0 = 0;
6987 dgst_pos1 = 3;
6988 dgst_pos2 = 2;
6989 dgst_pos3 = 1;
6990 break;
6991
6992 case 50: hash_type = HASH_TYPE_MD5;
6993 salt_type = SALT_TYPE_INTERN;
6994 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6995 opts_type = OPTS_TYPE_PT_GENERATE_LE
6996 | OPTS_TYPE_ST_ADD80
6997 | OPTS_TYPE_ST_ADDBITS14;
6998 kern_type = KERN_TYPE_HMACMD5_PW;
6999 dgst_size = DGST_SIZE_4_4;
7000 parse_func = hmacmd5_parse_hash;
7001 sort_by_digest = sort_by_digest_4_4;
7002 opti_type = OPTI_TYPE_ZERO_BYTE
7003 | OPTI_TYPE_NOT_ITERATED;
7004 dgst_pos0 = 0;
7005 dgst_pos1 = 3;
7006 dgst_pos2 = 2;
7007 dgst_pos3 = 1;
7008 break;
7009
7010 case 60: hash_type = HASH_TYPE_MD5;
7011 salt_type = SALT_TYPE_INTERN;
7012 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7013 opts_type = OPTS_TYPE_PT_GENERATE_LE
7014 | OPTS_TYPE_PT_ADD80
7015 | OPTS_TYPE_PT_ADDBITS14;
7016 kern_type = KERN_TYPE_HMACMD5_SLT;
7017 dgst_size = DGST_SIZE_4_4;
7018 parse_func = hmacmd5_parse_hash;
7019 sort_by_digest = sort_by_digest_4_4;
7020 opti_type = OPTI_TYPE_ZERO_BYTE
7021 | OPTI_TYPE_NOT_ITERATED;
7022 dgst_pos0 = 0;
7023 dgst_pos1 = 3;
7024 dgst_pos2 = 2;
7025 dgst_pos3 = 1;
7026 break;
7027
7028 case 100: hash_type = HASH_TYPE_SHA1;
7029 salt_type = SALT_TYPE_NONE;
7030 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7031 opts_type = OPTS_TYPE_PT_GENERATE_BE
7032 | OPTS_TYPE_PT_ADD80
7033 | OPTS_TYPE_PT_ADDBITS15;
7034 kern_type = KERN_TYPE_SHA1;
7035 dgst_size = DGST_SIZE_4_5;
7036 parse_func = sha1_parse_hash;
7037 sort_by_digest = sort_by_digest_4_5;
7038 opti_type = OPTI_TYPE_ZERO_BYTE
7039 | OPTI_TYPE_PRECOMPUTE_INIT
7040 | OPTI_TYPE_PRECOMPUTE_MERKLE
7041 | OPTI_TYPE_EARLY_SKIP
7042 | OPTI_TYPE_NOT_ITERATED
7043 | OPTI_TYPE_NOT_SALTED
7044 | OPTI_TYPE_RAW_HASH;
7045 dgst_pos0 = 3;
7046 dgst_pos1 = 4;
7047 dgst_pos2 = 2;
7048 dgst_pos3 = 1;
7049 break;
7050
7051 case 101: hash_type = HASH_TYPE_SHA1;
7052 salt_type = SALT_TYPE_NONE;
7053 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7054 opts_type = OPTS_TYPE_PT_GENERATE_BE
7055 | OPTS_TYPE_PT_ADD80
7056 | OPTS_TYPE_PT_ADDBITS15;
7057 kern_type = KERN_TYPE_SHA1;
7058 dgst_size = DGST_SIZE_4_5;
7059 parse_func = sha1b64_parse_hash;
7060 sort_by_digest = sort_by_digest_4_5;
7061 opti_type = OPTI_TYPE_ZERO_BYTE
7062 | OPTI_TYPE_PRECOMPUTE_INIT
7063 | OPTI_TYPE_PRECOMPUTE_MERKLE
7064 | OPTI_TYPE_EARLY_SKIP
7065 | OPTI_TYPE_NOT_ITERATED
7066 | OPTI_TYPE_NOT_SALTED
7067 | OPTI_TYPE_RAW_HASH;
7068 dgst_pos0 = 3;
7069 dgst_pos1 = 4;
7070 dgst_pos2 = 2;
7071 dgst_pos3 = 1;
7072 break;
7073
7074 case 110: hash_type = HASH_TYPE_SHA1;
7075 salt_type = SALT_TYPE_INTERN;
7076 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7077 opts_type = OPTS_TYPE_PT_GENERATE_BE
7078 | OPTS_TYPE_ST_ADD80
7079 | OPTS_TYPE_ST_ADDBITS15;
7080 kern_type = KERN_TYPE_SHA1_PWSLT;
7081 dgst_size = DGST_SIZE_4_5;
7082 parse_func = sha1s_parse_hash;
7083 sort_by_digest = sort_by_digest_4_5;
7084 opti_type = OPTI_TYPE_ZERO_BYTE
7085 | OPTI_TYPE_PRECOMPUTE_INIT
7086 | OPTI_TYPE_PRECOMPUTE_MERKLE
7087 | OPTI_TYPE_EARLY_SKIP
7088 | OPTI_TYPE_NOT_ITERATED
7089 | OPTI_TYPE_APPENDED_SALT
7090 | OPTI_TYPE_RAW_HASH;
7091 dgst_pos0 = 3;
7092 dgst_pos1 = 4;
7093 dgst_pos2 = 2;
7094 dgst_pos3 = 1;
7095 break;
7096
7097 case 111: hash_type = HASH_TYPE_SHA1;
7098 salt_type = SALT_TYPE_EMBEDDED;
7099 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7100 opts_type = OPTS_TYPE_PT_GENERATE_BE
7101 | OPTS_TYPE_ST_ADD80
7102 | OPTS_TYPE_ST_ADDBITS15;
7103 kern_type = KERN_TYPE_SHA1_PWSLT;
7104 dgst_size = DGST_SIZE_4_5;
7105 parse_func = sha1b64s_parse_hash;
7106 sort_by_digest = sort_by_digest_4_5;
7107 opti_type = OPTI_TYPE_ZERO_BYTE
7108 | OPTI_TYPE_PRECOMPUTE_INIT
7109 | OPTI_TYPE_PRECOMPUTE_MERKLE
7110 | OPTI_TYPE_EARLY_SKIP
7111 | OPTI_TYPE_NOT_ITERATED
7112 | OPTI_TYPE_APPENDED_SALT
7113 | OPTI_TYPE_RAW_HASH;
7114 dgst_pos0 = 3;
7115 dgst_pos1 = 4;
7116 dgst_pos2 = 2;
7117 dgst_pos3 = 1;
7118 break;
7119
7120 case 112: hash_type = HASH_TYPE_SHA1;
7121 salt_type = SALT_TYPE_INTERN;
7122 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7123 opts_type = OPTS_TYPE_PT_GENERATE_BE
7124 | OPTS_TYPE_ST_ADD80
7125 | OPTS_TYPE_ST_ADDBITS15
7126 | OPTS_TYPE_ST_HEX;
7127 kern_type = KERN_TYPE_SHA1_PWSLT;
7128 dgst_size = DGST_SIZE_4_5;
7129 parse_func = oracles_parse_hash;
7130 sort_by_digest = sort_by_digest_4_5;
7131 opti_type = OPTI_TYPE_ZERO_BYTE
7132 | OPTI_TYPE_PRECOMPUTE_INIT
7133 | OPTI_TYPE_PRECOMPUTE_MERKLE
7134 | OPTI_TYPE_EARLY_SKIP
7135 | OPTI_TYPE_NOT_ITERATED
7136 | OPTI_TYPE_APPENDED_SALT
7137 | OPTI_TYPE_RAW_HASH;
7138 dgst_pos0 = 3;
7139 dgst_pos1 = 4;
7140 dgst_pos2 = 2;
7141 dgst_pos3 = 1;
7142 break;
7143
7144 case 120: hash_type = HASH_TYPE_SHA1;
7145 salt_type = SALT_TYPE_INTERN;
7146 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7147 opts_type = OPTS_TYPE_PT_GENERATE_BE
7148 | OPTS_TYPE_PT_ADD80
7149 | OPTS_TYPE_PT_ADDBITS15;
7150 kern_type = KERN_TYPE_SHA1_SLTPW;
7151 dgst_size = DGST_SIZE_4_5;
7152 parse_func = sha1s_parse_hash;
7153 sort_by_digest = sort_by_digest_4_5;
7154 opti_type = OPTI_TYPE_ZERO_BYTE
7155 | OPTI_TYPE_PRECOMPUTE_INIT
7156 | OPTI_TYPE_PRECOMPUTE_MERKLE
7157 | OPTI_TYPE_EARLY_SKIP
7158 | OPTI_TYPE_NOT_ITERATED
7159 | OPTI_TYPE_PREPENDED_SALT
7160 | OPTI_TYPE_RAW_HASH;
7161 dgst_pos0 = 3;
7162 dgst_pos1 = 4;
7163 dgst_pos2 = 2;
7164 dgst_pos3 = 1;
7165 break;
7166
7167 case 121: hash_type = HASH_TYPE_SHA1;
7168 salt_type = SALT_TYPE_INTERN;
7169 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7170 opts_type = OPTS_TYPE_PT_GENERATE_BE
7171 | OPTS_TYPE_PT_ADD80
7172 | OPTS_TYPE_PT_ADDBITS15
7173 | OPTS_TYPE_ST_LOWER;
7174 kern_type = KERN_TYPE_SHA1_SLTPW;
7175 dgst_size = DGST_SIZE_4_5;
7176 parse_func = smf_parse_hash;
7177 sort_by_digest = sort_by_digest_4_5;
7178 opti_type = OPTI_TYPE_ZERO_BYTE
7179 | OPTI_TYPE_PRECOMPUTE_INIT
7180 | OPTI_TYPE_PRECOMPUTE_MERKLE
7181 | OPTI_TYPE_EARLY_SKIP
7182 | OPTI_TYPE_NOT_ITERATED
7183 | OPTI_TYPE_PREPENDED_SALT
7184 | OPTI_TYPE_RAW_HASH;
7185 dgst_pos0 = 3;
7186 dgst_pos1 = 4;
7187 dgst_pos2 = 2;
7188 dgst_pos3 = 1;
7189 break;
7190
7191 case 122: hash_type = HASH_TYPE_SHA1;
7192 salt_type = SALT_TYPE_EMBEDDED;
7193 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7194 opts_type = OPTS_TYPE_PT_GENERATE_BE
7195 | OPTS_TYPE_PT_ADD80
7196 | OPTS_TYPE_PT_ADDBITS15
7197 | OPTS_TYPE_ST_HEX;
7198 kern_type = KERN_TYPE_SHA1_SLTPW;
7199 dgst_size = DGST_SIZE_4_5;
7200 parse_func = osx1_parse_hash;
7201 sort_by_digest = sort_by_digest_4_5;
7202 opti_type = OPTI_TYPE_ZERO_BYTE
7203 | OPTI_TYPE_PRECOMPUTE_INIT
7204 | OPTI_TYPE_PRECOMPUTE_MERKLE
7205 | OPTI_TYPE_EARLY_SKIP
7206 | OPTI_TYPE_NOT_ITERATED
7207 | OPTI_TYPE_PREPENDED_SALT
7208 | OPTI_TYPE_RAW_HASH;
7209 dgst_pos0 = 3;
7210 dgst_pos1 = 4;
7211 dgst_pos2 = 2;
7212 dgst_pos3 = 1;
7213 break;
7214
7215 case 124: hash_type = HASH_TYPE_SHA1;
7216 salt_type = SALT_TYPE_EMBEDDED;
7217 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7218 opts_type = OPTS_TYPE_PT_GENERATE_BE
7219 | OPTS_TYPE_PT_ADD80
7220 | OPTS_TYPE_PT_ADDBITS15;
7221 kern_type = KERN_TYPE_SHA1_SLTPW;
7222 dgst_size = DGST_SIZE_4_5;
7223 parse_func = djangosha1_parse_hash;
7224 sort_by_digest = sort_by_digest_4_5;
7225 opti_type = OPTI_TYPE_ZERO_BYTE
7226 | OPTI_TYPE_PRECOMPUTE_INIT
7227 | OPTI_TYPE_PRECOMPUTE_MERKLE
7228 | OPTI_TYPE_EARLY_SKIP
7229 | OPTI_TYPE_NOT_ITERATED
7230 | OPTI_TYPE_PREPENDED_SALT
7231 | OPTI_TYPE_RAW_HASH;
7232 dgst_pos0 = 3;
7233 dgst_pos1 = 4;
7234 dgst_pos2 = 2;
7235 dgst_pos3 = 1;
7236 break;
7237
7238 case 125: hash_type = HASH_TYPE_SHA1;
7239 salt_type = SALT_TYPE_EMBEDDED;
7240 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7241 opts_type = OPTS_TYPE_PT_GENERATE_BE
7242 | OPTS_TYPE_PT_ADD80
7243 | OPTS_TYPE_PT_ADDBITS15
7244 | OPTS_TYPE_ST_HEX;
7245 kern_type = KERN_TYPE_SHA1_SLTPW;
7246 dgst_size = DGST_SIZE_4_5;
7247 parse_func = arubaos_parse_hash;
7248 sort_by_digest = sort_by_digest_4_5;
7249 opti_type = OPTI_TYPE_ZERO_BYTE
7250 | OPTI_TYPE_PRECOMPUTE_INIT
7251 | OPTI_TYPE_PRECOMPUTE_MERKLE
7252 | OPTI_TYPE_EARLY_SKIP
7253 | OPTI_TYPE_NOT_ITERATED
7254 | OPTI_TYPE_PREPENDED_SALT
7255 | OPTI_TYPE_RAW_HASH;
7256 dgst_pos0 = 3;
7257 dgst_pos1 = 4;
7258 dgst_pos2 = 2;
7259 dgst_pos3 = 1;
7260 break;
7261
7262 case 130: hash_type = HASH_TYPE_SHA1;
7263 salt_type = SALT_TYPE_INTERN;
7264 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7265 opts_type = OPTS_TYPE_PT_GENERATE_BE
7266 | OPTS_TYPE_PT_UNICODE
7267 | OPTS_TYPE_ST_ADD80
7268 | OPTS_TYPE_ST_ADDBITS15;
7269 kern_type = KERN_TYPE_SHA1_PWUSLT;
7270 dgst_size = DGST_SIZE_4_5;
7271 parse_func = sha1s_parse_hash;
7272 sort_by_digest = sort_by_digest_4_5;
7273 opti_type = OPTI_TYPE_ZERO_BYTE
7274 | OPTI_TYPE_PRECOMPUTE_INIT
7275 | OPTI_TYPE_PRECOMPUTE_MERKLE
7276 | OPTI_TYPE_EARLY_SKIP
7277 | OPTI_TYPE_NOT_ITERATED
7278 | OPTI_TYPE_APPENDED_SALT
7279 | OPTI_TYPE_RAW_HASH;
7280 dgst_pos0 = 3;
7281 dgst_pos1 = 4;
7282 dgst_pos2 = 2;
7283 dgst_pos3 = 1;
7284 break;
7285
7286 case 131: hash_type = HASH_TYPE_SHA1;
7287 salt_type = SALT_TYPE_EMBEDDED;
7288 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7289 opts_type = OPTS_TYPE_PT_GENERATE_BE
7290 | OPTS_TYPE_PT_UNICODE
7291 | OPTS_TYPE_PT_UPPER
7292 | OPTS_TYPE_ST_ADD80
7293 | OPTS_TYPE_ST_ADDBITS15
7294 | OPTS_TYPE_ST_HEX;
7295 kern_type = KERN_TYPE_SHA1_PWUSLT;
7296 dgst_size = DGST_SIZE_4_5;
7297 parse_func = mssql2000_parse_hash;
7298 sort_by_digest = sort_by_digest_4_5;
7299 opti_type = OPTI_TYPE_ZERO_BYTE
7300 | OPTI_TYPE_PRECOMPUTE_INIT
7301 | OPTI_TYPE_PRECOMPUTE_MERKLE
7302 | OPTI_TYPE_EARLY_SKIP
7303 | OPTI_TYPE_NOT_ITERATED
7304 | OPTI_TYPE_APPENDED_SALT
7305 | OPTI_TYPE_RAW_HASH;
7306 dgst_pos0 = 3;
7307 dgst_pos1 = 4;
7308 dgst_pos2 = 2;
7309 dgst_pos3 = 1;
7310 break;
7311
7312 case 132: hash_type = HASH_TYPE_SHA1;
7313 salt_type = SALT_TYPE_EMBEDDED;
7314 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7315 opts_type = OPTS_TYPE_PT_GENERATE_BE
7316 | OPTS_TYPE_PT_UNICODE
7317 | OPTS_TYPE_ST_ADD80
7318 | OPTS_TYPE_ST_ADDBITS15
7319 | OPTS_TYPE_ST_HEX;
7320 kern_type = KERN_TYPE_SHA1_PWUSLT;
7321 dgst_size = DGST_SIZE_4_5;
7322 parse_func = mssql2005_parse_hash;
7323 sort_by_digest = sort_by_digest_4_5;
7324 opti_type = OPTI_TYPE_ZERO_BYTE
7325 | OPTI_TYPE_PRECOMPUTE_INIT
7326 | OPTI_TYPE_PRECOMPUTE_MERKLE
7327 | OPTI_TYPE_EARLY_SKIP
7328 | OPTI_TYPE_NOT_ITERATED
7329 | OPTI_TYPE_APPENDED_SALT
7330 | OPTI_TYPE_RAW_HASH;
7331 dgst_pos0 = 3;
7332 dgst_pos1 = 4;
7333 dgst_pos2 = 2;
7334 dgst_pos3 = 1;
7335 break;
7336
7337 case 133: hash_type = HASH_TYPE_SHA1;
7338 salt_type = SALT_TYPE_EMBEDDED;
7339 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7340 opts_type = OPTS_TYPE_PT_GENERATE_BE
7341 | OPTS_TYPE_PT_UNICODE
7342 | OPTS_TYPE_ST_ADD80
7343 | OPTS_TYPE_ST_ADDBITS15;
7344 kern_type = KERN_TYPE_SHA1_PWUSLT;
7345 dgst_size = DGST_SIZE_4_5;
7346 parse_func = peoplesoft_parse_hash;
7347 sort_by_digest = sort_by_digest_4_5;
7348 opti_type = OPTI_TYPE_ZERO_BYTE
7349 | OPTI_TYPE_PRECOMPUTE_INIT
7350 | OPTI_TYPE_PRECOMPUTE_MERKLE
7351 | OPTI_TYPE_EARLY_SKIP
7352 | OPTI_TYPE_NOT_ITERATED
7353 | OPTI_TYPE_APPENDED_SALT
7354 | OPTI_TYPE_RAW_HASH;
7355 dgst_pos0 = 3;
7356 dgst_pos1 = 4;
7357 dgst_pos2 = 2;
7358 dgst_pos3 = 1;
7359 break;
7360
7361 case 140: hash_type = HASH_TYPE_SHA1;
7362 salt_type = SALT_TYPE_INTERN;
7363 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7364 opts_type = OPTS_TYPE_PT_GENERATE_BE
7365 | OPTS_TYPE_PT_ADD80
7366 | OPTS_TYPE_PT_ADDBITS15
7367 | OPTS_TYPE_PT_UNICODE;
7368 kern_type = KERN_TYPE_SHA1_SLTPWU;
7369 dgst_size = DGST_SIZE_4_5;
7370 parse_func = sha1s_parse_hash;
7371 sort_by_digest = sort_by_digest_4_5;
7372 opti_type = OPTI_TYPE_ZERO_BYTE
7373 | OPTI_TYPE_PRECOMPUTE_INIT
7374 | OPTI_TYPE_PRECOMPUTE_MERKLE
7375 | OPTI_TYPE_EARLY_SKIP
7376 | OPTI_TYPE_NOT_ITERATED
7377 | OPTI_TYPE_PREPENDED_SALT
7378 | OPTI_TYPE_RAW_HASH;
7379 dgst_pos0 = 3;
7380 dgst_pos1 = 4;
7381 dgst_pos2 = 2;
7382 dgst_pos3 = 1;
7383 break;
7384
7385 case 141: hash_type = HASH_TYPE_SHA1;
7386 salt_type = SALT_TYPE_EMBEDDED;
7387 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7388 opts_type = OPTS_TYPE_PT_GENERATE_BE
7389 | OPTS_TYPE_PT_ADD80
7390 | OPTS_TYPE_PT_ADDBITS15
7391 | OPTS_TYPE_PT_UNICODE
7392 | OPTS_TYPE_ST_BASE64;
7393 kern_type = KERN_TYPE_SHA1_SLTPWU;
7394 dgst_size = DGST_SIZE_4_5;
7395 parse_func = episerver_parse_hash;
7396 sort_by_digest = sort_by_digest_4_5;
7397 opti_type = OPTI_TYPE_ZERO_BYTE
7398 | OPTI_TYPE_PRECOMPUTE_INIT
7399 | OPTI_TYPE_PRECOMPUTE_MERKLE
7400 | OPTI_TYPE_EARLY_SKIP
7401 | OPTI_TYPE_NOT_ITERATED
7402 | OPTI_TYPE_PREPENDED_SALT
7403 | OPTI_TYPE_RAW_HASH;
7404 dgst_pos0 = 3;
7405 dgst_pos1 = 4;
7406 dgst_pos2 = 2;
7407 dgst_pos3 = 1;
7408 break;
7409
7410 case 150: hash_type = HASH_TYPE_SHA1;
7411 salt_type = SALT_TYPE_INTERN;
7412 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7413 opts_type = OPTS_TYPE_PT_GENERATE_BE
7414 | OPTS_TYPE_ST_ADD80
7415 | OPTS_TYPE_ST_ADDBITS15;
7416 kern_type = KERN_TYPE_HMACSHA1_PW;
7417 dgst_size = DGST_SIZE_4_5;
7418 parse_func = hmacsha1_parse_hash;
7419 sort_by_digest = sort_by_digest_4_5;
7420 opti_type = OPTI_TYPE_ZERO_BYTE
7421 | OPTI_TYPE_NOT_ITERATED;
7422 dgst_pos0 = 3;
7423 dgst_pos1 = 4;
7424 dgst_pos2 = 2;
7425 dgst_pos3 = 1;
7426 break;
7427
7428 case 160: hash_type = HASH_TYPE_SHA1;
7429 salt_type = SALT_TYPE_INTERN;
7430 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7431 opts_type = OPTS_TYPE_PT_GENERATE_BE
7432 | OPTS_TYPE_PT_ADD80
7433 | OPTS_TYPE_PT_ADDBITS15;
7434 kern_type = KERN_TYPE_HMACSHA1_SLT;
7435 dgst_size = DGST_SIZE_4_5;
7436 parse_func = hmacsha1_parse_hash;
7437 sort_by_digest = sort_by_digest_4_5;
7438 opti_type = OPTI_TYPE_ZERO_BYTE
7439 | OPTI_TYPE_NOT_ITERATED;
7440 dgst_pos0 = 3;
7441 dgst_pos1 = 4;
7442 dgst_pos2 = 2;
7443 dgst_pos3 = 1;
7444 break;
7445
7446 case 190: hash_type = HASH_TYPE_SHA1;
7447 salt_type = SALT_TYPE_NONE;
7448 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7449 opts_type = OPTS_TYPE_PT_GENERATE_BE
7450 | OPTS_TYPE_PT_ADD80
7451 | OPTS_TYPE_PT_ADDBITS15;
7452 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7453 dgst_size = DGST_SIZE_4_5;
7454 parse_func = sha1linkedin_parse_hash;
7455 sort_by_digest = sort_by_digest_4_5;
7456 opti_type = OPTI_TYPE_ZERO_BYTE
7457 | OPTI_TYPE_PRECOMPUTE_INIT
7458 | OPTI_TYPE_EARLY_SKIP
7459 | OPTI_TYPE_NOT_ITERATED
7460 | OPTI_TYPE_NOT_SALTED;
7461 dgst_pos0 = 0;
7462 dgst_pos1 = 4;
7463 dgst_pos2 = 3;
7464 dgst_pos3 = 2;
7465 break;
7466
7467 case 200: hash_type = HASH_TYPE_MYSQL;
7468 salt_type = SALT_TYPE_NONE;
7469 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7470 opts_type = 0;
7471 kern_type = KERN_TYPE_MYSQL;
7472 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7473 parse_func = mysql323_parse_hash;
7474 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7475 opti_type = OPTI_TYPE_ZERO_BYTE;
7476 dgst_pos0 = 0;
7477 dgst_pos1 = 1;
7478 dgst_pos2 = 2;
7479 dgst_pos3 = 3;
7480 break;
7481
7482 case 300: hash_type = HASH_TYPE_SHA1;
7483 salt_type = SALT_TYPE_NONE;
7484 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7485 opts_type = OPTS_TYPE_PT_GENERATE_BE
7486 | OPTS_TYPE_PT_ADD80
7487 | OPTS_TYPE_PT_ADDBITS15;
7488 kern_type = KERN_TYPE_MYSQL41;
7489 dgst_size = DGST_SIZE_4_5;
7490 parse_func = sha1_parse_hash;
7491 sort_by_digest = sort_by_digest_4_5;
7492 opti_type = OPTI_TYPE_ZERO_BYTE
7493 | OPTI_TYPE_PRECOMPUTE_INIT
7494 | OPTI_TYPE_PRECOMPUTE_MERKLE
7495 | OPTI_TYPE_EARLY_SKIP
7496 | OPTI_TYPE_NOT_ITERATED
7497 | OPTI_TYPE_NOT_SALTED;
7498 dgst_pos0 = 3;
7499 dgst_pos1 = 4;
7500 dgst_pos2 = 2;
7501 dgst_pos3 = 1;
7502 break;
7503
7504 case 400: hash_type = HASH_TYPE_MD5;
7505 salt_type = SALT_TYPE_EMBEDDED;
7506 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7507 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7508 kern_type = KERN_TYPE_PHPASS;
7509 dgst_size = DGST_SIZE_4_4;
7510 parse_func = phpass_parse_hash;
7511 sort_by_digest = sort_by_digest_4_4;
7512 opti_type = OPTI_TYPE_ZERO_BYTE
7513 | OPTI_TYPE_SLOW_HASH_SIMD;
7514 dgst_pos0 = 0;
7515 dgst_pos1 = 1;
7516 dgst_pos2 = 2;
7517 dgst_pos3 = 3;
7518 break;
7519
7520 case 500: hash_type = HASH_TYPE_MD5;
7521 salt_type = SALT_TYPE_EMBEDDED;
7522 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7523 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7524 kern_type = KERN_TYPE_MD5CRYPT;
7525 dgst_size = DGST_SIZE_4_4;
7526 parse_func = md5crypt_parse_hash;
7527 sort_by_digest = sort_by_digest_4_4;
7528 opti_type = OPTI_TYPE_ZERO_BYTE;
7529 dgst_pos0 = 0;
7530 dgst_pos1 = 1;
7531 dgst_pos2 = 2;
7532 dgst_pos3 = 3;
7533 break;
7534
7535 case 501: hash_type = HASH_TYPE_MD5;
7536 salt_type = SALT_TYPE_EMBEDDED;
7537 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7538 opts_type = OPTS_TYPE_PT_GENERATE_LE
7539 | OPTS_TYPE_HASH_COPY;
7540 kern_type = KERN_TYPE_MD5CRYPT;
7541 dgst_size = DGST_SIZE_4_4;
7542 parse_func = juniper_parse_hash;
7543 sort_by_digest = sort_by_digest_4_4;
7544 opti_type = OPTI_TYPE_ZERO_BYTE;
7545 dgst_pos0 = 0;
7546 dgst_pos1 = 1;
7547 dgst_pos2 = 2;
7548 dgst_pos3 = 3;
7549 break;
7550
7551 case 900: hash_type = HASH_TYPE_MD4;
7552 salt_type = SALT_TYPE_NONE;
7553 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7554 opts_type = OPTS_TYPE_PT_GENERATE_LE
7555 | OPTS_TYPE_PT_ADD80
7556 | OPTS_TYPE_PT_ADDBITS14;
7557 kern_type = KERN_TYPE_MD4;
7558 dgst_size = DGST_SIZE_4_4;
7559 parse_func = md4_parse_hash;
7560 sort_by_digest = sort_by_digest_4_4;
7561 opti_type = OPTI_TYPE_ZERO_BYTE
7562 | OPTI_TYPE_PRECOMPUTE_INIT
7563 | OPTI_TYPE_PRECOMPUTE_MERKLE
7564 | OPTI_TYPE_MEET_IN_MIDDLE
7565 | OPTI_TYPE_EARLY_SKIP
7566 | OPTI_TYPE_NOT_ITERATED
7567 | OPTI_TYPE_NOT_SALTED
7568 | OPTI_TYPE_RAW_HASH;
7569 dgst_pos0 = 0;
7570 dgst_pos1 = 3;
7571 dgst_pos2 = 2;
7572 dgst_pos3 = 1;
7573 break;
7574
7575 case 1000: hash_type = HASH_TYPE_MD4;
7576 salt_type = SALT_TYPE_NONE;
7577 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7578 opts_type = OPTS_TYPE_PT_GENERATE_LE
7579 | OPTS_TYPE_PT_ADD80
7580 | OPTS_TYPE_PT_ADDBITS14
7581 | OPTS_TYPE_PT_UNICODE;
7582 kern_type = KERN_TYPE_MD4_PWU;
7583 dgst_size = DGST_SIZE_4_4;
7584 parse_func = md4_parse_hash;
7585 sort_by_digest = sort_by_digest_4_4;
7586 opti_type = OPTI_TYPE_ZERO_BYTE
7587 | OPTI_TYPE_PRECOMPUTE_INIT
7588 | OPTI_TYPE_PRECOMPUTE_MERKLE
7589 | OPTI_TYPE_MEET_IN_MIDDLE
7590 | OPTI_TYPE_EARLY_SKIP
7591 | OPTI_TYPE_NOT_ITERATED
7592 | OPTI_TYPE_NOT_SALTED
7593 | OPTI_TYPE_RAW_HASH;
7594 dgst_pos0 = 0;
7595 dgst_pos1 = 3;
7596 dgst_pos2 = 2;
7597 dgst_pos3 = 1;
7598 break;
7599
7600 case 1100: hash_type = HASH_TYPE_MD4;
7601 salt_type = SALT_TYPE_INTERN;
7602 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7603 opts_type = OPTS_TYPE_PT_GENERATE_LE
7604 | OPTS_TYPE_PT_ADD80
7605 | OPTS_TYPE_PT_ADDBITS14
7606 | OPTS_TYPE_PT_UNICODE
7607 | OPTS_TYPE_ST_ADD80
7608 | OPTS_TYPE_ST_UNICODE
7609 | OPTS_TYPE_ST_LOWER;
7610 kern_type = KERN_TYPE_MD44_PWUSLT;
7611 dgst_size = DGST_SIZE_4_4;
7612 parse_func = dcc_parse_hash;
7613 sort_by_digest = sort_by_digest_4_4;
7614 opti_type = OPTI_TYPE_ZERO_BYTE
7615 | OPTI_TYPE_PRECOMPUTE_INIT
7616 | OPTI_TYPE_PRECOMPUTE_MERKLE
7617 | OPTI_TYPE_EARLY_SKIP
7618 | OPTI_TYPE_NOT_ITERATED;
7619 dgst_pos0 = 0;
7620 dgst_pos1 = 3;
7621 dgst_pos2 = 2;
7622 dgst_pos3 = 1;
7623 break;
7624
7625 case 1400: hash_type = HASH_TYPE_SHA256;
7626 salt_type = SALT_TYPE_NONE;
7627 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7628 opts_type = OPTS_TYPE_PT_GENERATE_BE
7629 | OPTS_TYPE_PT_ADD80
7630 | OPTS_TYPE_PT_ADDBITS15;
7631 kern_type = KERN_TYPE_SHA256;
7632 dgst_size = DGST_SIZE_4_8;
7633 parse_func = sha256_parse_hash;
7634 sort_by_digest = sort_by_digest_4_8;
7635 opti_type = OPTI_TYPE_ZERO_BYTE
7636 | OPTI_TYPE_PRECOMPUTE_INIT
7637 | OPTI_TYPE_PRECOMPUTE_MERKLE
7638 | OPTI_TYPE_EARLY_SKIP
7639 | OPTI_TYPE_NOT_ITERATED
7640 | OPTI_TYPE_NOT_SALTED
7641 | OPTI_TYPE_RAW_HASH;
7642 dgst_pos0 = 3;
7643 dgst_pos1 = 7;
7644 dgst_pos2 = 2;
7645 dgst_pos3 = 6;
7646 break;
7647
7648 case 1410: hash_type = HASH_TYPE_SHA256;
7649 salt_type = SALT_TYPE_INTERN;
7650 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7651 opts_type = OPTS_TYPE_PT_GENERATE_BE
7652 | OPTS_TYPE_ST_ADD80
7653 | OPTS_TYPE_ST_ADDBITS15;
7654 kern_type = KERN_TYPE_SHA256_PWSLT;
7655 dgst_size = DGST_SIZE_4_8;
7656 parse_func = sha256s_parse_hash;
7657 sort_by_digest = sort_by_digest_4_8;
7658 opti_type = OPTI_TYPE_ZERO_BYTE
7659 | OPTI_TYPE_PRECOMPUTE_INIT
7660 | OPTI_TYPE_PRECOMPUTE_MERKLE
7661 | OPTI_TYPE_EARLY_SKIP
7662 | OPTI_TYPE_NOT_ITERATED
7663 | OPTI_TYPE_APPENDED_SALT
7664 | OPTI_TYPE_RAW_HASH;
7665 dgst_pos0 = 3;
7666 dgst_pos1 = 7;
7667 dgst_pos2 = 2;
7668 dgst_pos3 = 6;
7669 break;
7670
7671 case 1420: hash_type = HASH_TYPE_SHA256;
7672 salt_type = SALT_TYPE_INTERN;
7673 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7674 opts_type = OPTS_TYPE_PT_GENERATE_BE
7675 | OPTS_TYPE_PT_ADD80
7676 | OPTS_TYPE_PT_ADDBITS15;
7677 kern_type = KERN_TYPE_SHA256_SLTPW;
7678 dgst_size = DGST_SIZE_4_8;
7679 parse_func = sha256s_parse_hash;
7680 sort_by_digest = sort_by_digest_4_8;
7681 opti_type = OPTI_TYPE_ZERO_BYTE
7682 | OPTI_TYPE_PRECOMPUTE_INIT
7683 | OPTI_TYPE_PRECOMPUTE_MERKLE
7684 | OPTI_TYPE_EARLY_SKIP
7685 | OPTI_TYPE_NOT_ITERATED
7686 | OPTI_TYPE_PREPENDED_SALT
7687 | OPTI_TYPE_RAW_HASH;
7688 dgst_pos0 = 3;
7689 dgst_pos1 = 7;
7690 dgst_pos2 = 2;
7691 dgst_pos3 = 6;
7692 break;
7693
7694 case 1421: hash_type = HASH_TYPE_SHA256;
7695 salt_type = SALT_TYPE_EMBEDDED;
7696 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7697 opts_type = OPTS_TYPE_PT_GENERATE_BE
7698 | OPTS_TYPE_PT_ADD80
7699 | OPTS_TYPE_PT_ADDBITS15;
7700 kern_type = KERN_TYPE_SHA256_SLTPW;
7701 dgst_size = DGST_SIZE_4_8;
7702 parse_func = hmailserver_parse_hash;
7703 sort_by_digest = sort_by_digest_4_8;
7704 opti_type = OPTI_TYPE_ZERO_BYTE
7705 | OPTI_TYPE_PRECOMPUTE_INIT
7706 | OPTI_TYPE_PRECOMPUTE_MERKLE
7707 | OPTI_TYPE_EARLY_SKIP
7708 | OPTI_TYPE_NOT_ITERATED
7709 | OPTI_TYPE_PREPENDED_SALT
7710 | OPTI_TYPE_RAW_HASH;
7711 dgst_pos0 = 3;
7712 dgst_pos1 = 7;
7713 dgst_pos2 = 2;
7714 dgst_pos3 = 6;
7715 break;
7716
7717 case 1430: hash_type = HASH_TYPE_SHA256;
7718 salt_type = SALT_TYPE_INTERN;
7719 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7720 opts_type = OPTS_TYPE_PT_GENERATE_BE
7721 | OPTS_TYPE_PT_UNICODE
7722 | OPTS_TYPE_ST_ADD80
7723 | OPTS_TYPE_ST_ADDBITS15;
7724 kern_type = KERN_TYPE_SHA256_PWUSLT;
7725 dgst_size = DGST_SIZE_4_8;
7726 parse_func = sha256s_parse_hash;
7727 sort_by_digest = sort_by_digest_4_8;
7728 opti_type = OPTI_TYPE_ZERO_BYTE
7729 | OPTI_TYPE_PRECOMPUTE_INIT
7730 | OPTI_TYPE_PRECOMPUTE_MERKLE
7731 | OPTI_TYPE_EARLY_SKIP
7732 | OPTI_TYPE_NOT_ITERATED
7733 | OPTI_TYPE_APPENDED_SALT
7734 | OPTI_TYPE_RAW_HASH;
7735 dgst_pos0 = 3;
7736 dgst_pos1 = 7;
7737 dgst_pos2 = 2;
7738 dgst_pos3 = 6;
7739 break;
7740
7741 case 1440: hash_type = HASH_TYPE_SHA256;
7742 salt_type = SALT_TYPE_INTERN;
7743 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7744 opts_type = OPTS_TYPE_PT_GENERATE_BE
7745 | OPTS_TYPE_PT_ADD80
7746 | OPTS_TYPE_PT_ADDBITS15
7747 | OPTS_TYPE_PT_UNICODE;
7748 kern_type = KERN_TYPE_SHA256_SLTPWU;
7749 dgst_size = DGST_SIZE_4_8;
7750 parse_func = sha256s_parse_hash;
7751 sort_by_digest = sort_by_digest_4_8;
7752 opti_type = OPTI_TYPE_ZERO_BYTE
7753 | OPTI_TYPE_PRECOMPUTE_INIT
7754 | OPTI_TYPE_PRECOMPUTE_MERKLE
7755 | OPTI_TYPE_EARLY_SKIP
7756 | OPTI_TYPE_NOT_ITERATED
7757 | OPTI_TYPE_PREPENDED_SALT
7758 | OPTI_TYPE_RAW_HASH;
7759 dgst_pos0 = 3;
7760 dgst_pos1 = 7;
7761 dgst_pos2 = 2;
7762 dgst_pos3 = 6;
7763 break;
7764
7765 case 1441: hash_type = HASH_TYPE_SHA256;
7766 salt_type = SALT_TYPE_EMBEDDED;
7767 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7768 opts_type = OPTS_TYPE_PT_GENERATE_BE
7769 | OPTS_TYPE_PT_ADD80
7770 | OPTS_TYPE_PT_ADDBITS15
7771 | OPTS_TYPE_PT_UNICODE
7772 | OPTS_TYPE_ST_BASE64;
7773 kern_type = KERN_TYPE_SHA256_SLTPWU;
7774 dgst_size = DGST_SIZE_4_8;
7775 parse_func = episerver4_parse_hash;
7776 sort_by_digest = sort_by_digest_4_8;
7777 opti_type = OPTI_TYPE_ZERO_BYTE
7778 | OPTI_TYPE_PRECOMPUTE_INIT
7779 | OPTI_TYPE_PRECOMPUTE_MERKLE
7780 | OPTI_TYPE_EARLY_SKIP
7781 | OPTI_TYPE_NOT_ITERATED
7782 | OPTI_TYPE_PREPENDED_SALT
7783 | OPTI_TYPE_RAW_HASH;
7784 dgst_pos0 = 3;
7785 dgst_pos1 = 7;
7786 dgst_pos2 = 2;
7787 dgst_pos3 = 6;
7788 break;
7789
7790 case 1450: hash_type = HASH_TYPE_SHA256;
7791 salt_type = SALT_TYPE_INTERN;
7792 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7793 opts_type = OPTS_TYPE_PT_GENERATE_BE
7794 | OPTS_TYPE_ST_ADD80;
7795 kern_type = KERN_TYPE_HMACSHA256_PW;
7796 dgst_size = DGST_SIZE_4_8;
7797 parse_func = hmacsha256_parse_hash;
7798 sort_by_digest = sort_by_digest_4_8;
7799 opti_type = OPTI_TYPE_ZERO_BYTE
7800 | OPTI_TYPE_NOT_ITERATED;
7801 dgst_pos0 = 3;
7802 dgst_pos1 = 7;
7803 dgst_pos2 = 2;
7804 dgst_pos3 = 6;
7805 break;
7806
7807 case 1460: hash_type = HASH_TYPE_SHA256;
7808 salt_type = SALT_TYPE_INTERN;
7809 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7810 opts_type = OPTS_TYPE_PT_GENERATE_BE
7811 | OPTS_TYPE_PT_ADD80
7812 | OPTS_TYPE_PT_ADDBITS15;
7813 kern_type = KERN_TYPE_HMACSHA256_SLT;
7814 dgst_size = DGST_SIZE_4_8;
7815 parse_func = hmacsha256_parse_hash;
7816 sort_by_digest = sort_by_digest_4_8;
7817 opti_type = OPTI_TYPE_ZERO_BYTE
7818 | OPTI_TYPE_NOT_ITERATED;
7819 dgst_pos0 = 3;
7820 dgst_pos1 = 7;
7821 dgst_pos2 = 2;
7822 dgst_pos3 = 6;
7823 break;
7824
7825 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7826 salt_type = SALT_TYPE_EMBEDDED;
7827 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7828 opts_type = OPTS_TYPE_PT_GENERATE_LE
7829 | OPTS_TYPE_PT_BITSLICE;
7830 kern_type = KERN_TYPE_DESCRYPT;
7831 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7832 parse_func = descrypt_parse_hash;
7833 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7834 opti_type = OPTI_TYPE_ZERO_BYTE
7835 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7836 dgst_pos0 = 0;
7837 dgst_pos1 = 1;
7838 dgst_pos2 = 2;
7839 dgst_pos3 = 3;
7840 break;
7841
7842 case 1600: hash_type = HASH_TYPE_MD5;
7843 salt_type = SALT_TYPE_EMBEDDED;
7844 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7845 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7846 kern_type = KERN_TYPE_APR1CRYPT;
7847 dgst_size = DGST_SIZE_4_4;
7848 parse_func = md5apr1_parse_hash;
7849 sort_by_digest = sort_by_digest_4_4;
7850 opti_type = OPTI_TYPE_ZERO_BYTE;
7851 dgst_pos0 = 0;
7852 dgst_pos1 = 1;
7853 dgst_pos2 = 2;
7854 dgst_pos3 = 3;
7855 break;
7856
7857 case 1700: hash_type = HASH_TYPE_SHA512;
7858 salt_type = SALT_TYPE_NONE;
7859 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7860 opts_type = OPTS_TYPE_PT_GENERATE_BE
7861 | OPTS_TYPE_PT_ADD80
7862 | OPTS_TYPE_PT_ADDBITS15;
7863 kern_type = KERN_TYPE_SHA512;
7864 dgst_size = DGST_SIZE_8_8;
7865 parse_func = sha512_parse_hash;
7866 sort_by_digest = sort_by_digest_8_8;
7867 opti_type = OPTI_TYPE_ZERO_BYTE
7868 | OPTI_TYPE_PRECOMPUTE_INIT
7869 | OPTI_TYPE_PRECOMPUTE_MERKLE
7870 | OPTI_TYPE_EARLY_SKIP
7871 | OPTI_TYPE_NOT_ITERATED
7872 | OPTI_TYPE_NOT_SALTED
7873 | OPTI_TYPE_USES_BITS_64
7874 | OPTI_TYPE_RAW_HASH;
7875 dgst_pos0 = 14;
7876 dgst_pos1 = 15;
7877 dgst_pos2 = 6;
7878 dgst_pos3 = 7;
7879 break;
7880
7881 case 1710: hash_type = HASH_TYPE_SHA512;
7882 salt_type = SALT_TYPE_INTERN;
7883 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7884 opts_type = OPTS_TYPE_PT_GENERATE_BE
7885 | OPTS_TYPE_ST_ADD80
7886 | OPTS_TYPE_ST_ADDBITS15;
7887 kern_type = KERN_TYPE_SHA512_PWSLT;
7888 dgst_size = DGST_SIZE_8_8;
7889 parse_func = sha512s_parse_hash;
7890 sort_by_digest = sort_by_digest_8_8;
7891 opti_type = OPTI_TYPE_ZERO_BYTE
7892 | OPTI_TYPE_PRECOMPUTE_INIT
7893 | OPTI_TYPE_PRECOMPUTE_MERKLE
7894 | OPTI_TYPE_EARLY_SKIP
7895 | OPTI_TYPE_NOT_ITERATED
7896 | OPTI_TYPE_APPENDED_SALT
7897 | OPTI_TYPE_USES_BITS_64
7898 | OPTI_TYPE_RAW_HASH;
7899 dgst_pos0 = 14;
7900 dgst_pos1 = 15;
7901 dgst_pos2 = 6;
7902 dgst_pos3 = 7;
7903 break;
7904
7905 case 1711: hash_type = HASH_TYPE_SHA512;
7906 salt_type = SALT_TYPE_EMBEDDED;
7907 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7908 opts_type = OPTS_TYPE_PT_GENERATE_BE
7909 | OPTS_TYPE_ST_ADD80
7910 | OPTS_TYPE_ST_ADDBITS15;
7911 kern_type = KERN_TYPE_SHA512_PWSLT;
7912 dgst_size = DGST_SIZE_8_8;
7913 parse_func = sha512b64s_parse_hash;
7914 sort_by_digest = sort_by_digest_8_8;
7915 opti_type = OPTI_TYPE_ZERO_BYTE
7916 | OPTI_TYPE_PRECOMPUTE_INIT
7917 | OPTI_TYPE_PRECOMPUTE_MERKLE
7918 | OPTI_TYPE_EARLY_SKIP
7919 | OPTI_TYPE_NOT_ITERATED
7920 | OPTI_TYPE_APPENDED_SALT
7921 | OPTI_TYPE_USES_BITS_64
7922 | OPTI_TYPE_RAW_HASH;
7923 dgst_pos0 = 14;
7924 dgst_pos1 = 15;
7925 dgst_pos2 = 6;
7926 dgst_pos3 = 7;
7927 break;
7928
7929 case 1720: hash_type = HASH_TYPE_SHA512;
7930 salt_type = SALT_TYPE_INTERN;
7931 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7932 opts_type = OPTS_TYPE_PT_GENERATE_BE
7933 | OPTS_TYPE_PT_ADD80
7934 | OPTS_TYPE_PT_ADDBITS15;
7935 kern_type = KERN_TYPE_SHA512_SLTPW;
7936 dgst_size = DGST_SIZE_8_8;
7937 parse_func = sha512s_parse_hash;
7938 sort_by_digest = sort_by_digest_8_8;
7939 opti_type = OPTI_TYPE_ZERO_BYTE
7940 | OPTI_TYPE_PRECOMPUTE_INIT
7941 | OPTI_TYPE_PRECOMPUTE_MERKLE
7942 | OPTI_TYPE_EARLY_SKIP
7943 | OPTI_TYPE_NOT_ITERATED
7944 | OPTI_TYPE_PREPENDED_SALT
7945 | OPTI_TYPE_USES_BITS_64
7946 | OPTI_TYPE_RAW_HASH;
7947 dgst_pos0 = 14;
7948 dgst_pos1 = 15;
7949 dgst_pos2 = 6;
7950 dgst_pos3 = 7;
7951 break;
7952
7953 case 1722: hash_type = HASH_TYPE_SHA512;
7954 salt_type = SALT_TYPE_EMBEDDED;
7955 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7956 opts_type = OPTS_TYPE_PT_GENERATE_BE
7957 | OPTS_TYPE_PT_ADD80
7958 | OPTS_TYPE_PT_ADDBITS15
7959 | OPTS_TYPE_ST_HEX;
7960 kern_type = KERN_TYPE_SHA512_SLTPW;
7961 dgst_size = DGST_SIZE_8_8;
7962 parse_func = osx512_parse_hash;
7963 sort_by_digest = sort_by_digest_8_8;
7964 opti_type = OPTI_TYPE_ZERO_BYTE
7965 | OPTI_TYPE_PRECOMPUTE_INIT
7966 | OPTI_TYPE_PRECOMPUTE_MERKLE
7967 | OPTI_TYPE_EARLY_SKIP
7968 | OPTI_TYPE_NOT_ITERATED
7969 | OPTI_TYPE_PREPENDED_SALT
7970 | OPTI_TYPE_USES_BITS_64
7971 | OPTI_TYPE_RAW_HASH;
7972 dgst_pos0 = 14;
7973 dgst_pos1 = 15;
7974 dgst_pos2 = 6;
7975 dgst_pos3 = 7;
7976 break;
7977
7978 case 1730: hash_type = HASH_TYPE_SHA512;
7979 salt_type = SALT_TYPE_INTERN;
7980 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7981 opts_type = OPTS_TYPE_PT_GENERATE_BE
7982 | OPTS_TYPE_PT_UNICODE
7983 | OPTS_TYPE_ST_ADD80
7984 | OPTS_TYPE_ST_ADDBITS15;
7985 kern_type = KERN_TYPE_SHA512_PWSLTU;
7986 dgst_size = DGST_SIZE_8_8;
7987 parse_func = sha512s_parse_hash;
7988 sort_by_digest = sort_by_digest_8_8;
7989 opti_type = OPTI_TYPE_ZERO_BYTE
7990 | OPTI_TYPE_PRECOMPUTE_INIT
7991 | OPTI_TYPE_PRECOMPUTE_MERKLE
7992 | OPTI_TYPE_EARLY_SKIP
7993 | OPTI_TYPE_NOT_ITERATED
7994 | OPTI_TYPE_APPENDED_SALT
7995 | OPTI_TYPE_USES_BITS_64
7996 | OPTI_TYPE_RAW_HASH;
7997 dgst_pos0 = 14;
7998 dgst_pos1 = 15;
7999 dgst_pos2 = 6;
8000 dgst_pos3 = 7;
8001 break;
8002
8003 case 1731: hash_type = HASH_TYPE_SHA512;
8004 salt_type = SALT_TYPE_EMBEDDED;
8005 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8006 opts_type = OPTS_TYPE_PT_GENERATE_BE
8007 | OPTS_TYPE_PT_UNICODE
8008 | OPTS_TYPE_ST_ADD80
8009 | OPTS_TYPE_ST_ADDBITS15
8010 | OPTS_TYPE_ST_HEX;
8011 kern_type = KERN_TYPE_SHA512_PWSLTU;
8012 dgst_size = DGST_SIZE_8_8;
8013 parse_func = mssql2012_parse_hash;
8014 sort_by_digest = sort_by_digest_8_8;
8015 opti_type = OPTI_TYPE_ZERO_BYTE
8016 | OPTI_TYPE_PRECOMPUTE_INIT
8017 | OPTI_TYPE_PRECOMPUTE_MERKLE
8018 | OPTI_TYPE_EARLY_SKIP
8019 | OPTI_TYPE_NOT_ITERATED
8020 | OPTI_TYPE_APPENDED_SALT
8021 | OPTI_TYPE_USES_BITS_64
8022 | OPTI_TYPE_RAW_HASH;
8023 dgst_pos0 = 14;
8024 dgst_pos1 = 15;
8025 dgst_pos2 = 6;
8026 dgst_pos3 = 7;
8027 break;
8028
8029 case 1740: hash_type = HASH_TYPE_SHA512;
8030 salt_type = SALT_TYPE_INTERN;
8031 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8032 opts_type = OPTS_TYPE_PT_GENERATE_BE
8033 | OPTS_TYPE_PT_ADD80
8034 | OPTS_TYPE_PT_ADDBITS15
8035 | OPTS_TYPE_PT_UNICODE;
8036 kern_type = KERN_TYPE_SHA512_SLTPWU;
8037 dgst_size = DGST_SIZE_8_8;
8038 parse_func = sha512s_parse_hash;
8039 sort_by_digest = sort_by_digest_8_8;
8040 opti_type = OPTI_TYPE_ZERO_BYTE
8041 | OPTI_TYPE_PRECOMPUTE_INIT
8042 | OPTI_TYPE_PRECOMPUTE_MERKLE
8043 | OPTI_TYPE_EARLY_SKIP
8044 | OPTI_TYPE_NOT_ITERATED
8045 | OPTI_TYPE_PREPENDED_SALT
8046 | OPTI_TYPE_USES_BITS_64
8047 | OPTI_TYPE_RAW_HASH;
8048 dgst_pos0 = 14;
8049 dgst_pos1 = 15;
8050 dgst_pos2 = 6;
8051 dgst_pos3 = 7;
8052 break;
8053
8054 case 1750: hash_type = HASH_TYPE_SHA512;
8055 salt_type = SALT_TYPE_INTERN;
8056 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8057 opts_type = OPTS_TYPE_PT_GENERATE_BE
8058 | OPTS_TYPE_ST_ADD80;
8059 kern_type = KERN_TYPE_HMACSHA512_PW;
8060 dgst_size = DGST_SIZE_8_8;
8061 parse_func = hmacsha512_parse_hash;
8062 sort_by_digest = sort_by_digest_8_8;
8063 opti_type = OPTI_TYPE_ZERO_BYTE
8064 | OPTI_TYPE_USES_BITS_64
8065 | OPTI_TYPE_NOT_ITERATED;
8066 dgst_pos0 = 14;
8067 dgst_pos1 = 15;
8068 dgst_pos2 = 6;
8069 dgst_pos3 = 7;
8070 break;
8071
8072 case 1760: hash_type = HASH_TYPE_SHA512;
8073 salt_type = SALT_TYPE_INTERN;
8074 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8075 opts_type = OPTS_TYPE_PT_GENERATE_BE
8076 | OPTS_TYPE_PT_ADD80
8077 | OPTS_TYPE_PT_ADDBITS15;
8078 kern_type = KERN_TYPE_HMACSHA512_SLT;
8079 dgst_size = DGST_SIZE_8_8;
8080 parse_func = hmacsha512_parse_hash;
8081 sort_by_digest = sort_by_digest_8_8;
8082 opti_type = OPTI_TYPE_ZERO_BYTE
8083 | OPTI_TYPE_USES_BITS_64
8084 | OPTI_TYPE_NOT_ITERATED;
8085 dgst_pos0 = 14;
8086 dgst_pos1 = 15;
8087 dgst_pos2 = 6;
8088 dgst_pos3 = 7;
8089 break;
8090
8091 case 1800: hash_type = HASH_TYPE_SHA512;
8092 salt_type = SALT_TYPE_EMBEDDED;
8093 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8094 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8095 kern_type = KERN_TYPE_SHA512CRYPT;
8096 dgst_size = DGST_SIZE_8_8;
8097 parse_func = sha512crypt_parse_hash;
8098 sort_by_digest = sort_by_digest_8_8;
8099 opti_type = OPTI_TYPE_ZERO_BYTE
8100 | OPTI_TYPE_USES_BITS_64;
8101 dgst_pos0 = 0;
8102 dgst_pos1 = 1;
8103 dgst_pos2 = 2;
8104 dgst_pos3 = 3;
8105 break;
8106
8107 case 2100: hash_type = HASH_TYPE_DCC2;
8108 salt_type = SALT_TYPE_EMBEDDED;
8109 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8110 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8111 | OPTS_TYPE_ST_LOWER
8112 | OPTS_TYPE_ST_UNICODE;
8113 kern_type = KERN_TYPE_DCC2;
8114 dgst_size = DGST_SIZE_4_4;
8115 parse_func = dcc2_parse_hash;
8116 sort_by_digest = sort_by_digest_4_4;
8117 opti_type = OPTI_TYPE_ZERO_BYTE;
8118 dgst_pos0 = 0;
8119 dgst_pos1 = 1;
8120 dgst_pos2 = 2;
8121 dgst_pos3 = 3;
8122 break;
8123
8124 case 2400: hash_type = HASH_TYPE_MD5;
8125 salt_type = SALT_TYPE_NONE;
8126 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8127 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8128 kern_type = KERN_TYPE_MD5PIX;
8129 dgst_size = DGST_SIZE_4_4;
8130 parse_func = md5pix_parse_hash;
8131 sort_by_digest = sort_by_digest_4_4;
8132 opti_type = OPTI_TYPE_ZERO_BYTE
8133 | OPTI_TYPE_PRECOMPUTE_INIT
8134 | OPTI_TYPE_PRECOMPUTE_MERKLE
8135 | OPTI_TYPE_EARLY_SKIP
8136 | OPTI_TYPE_NOT_ITERATED
8137 | OPTI_TYPE_NOT_SALTED;
8138 dgst_pos0 = 0;
8139 dgst_pos1 = 3;
8140 dgst_pos2 = 2;
8141 dgst_pos3 = 1;
8142 break;
8143
8144 case 2410: hash_type = HASH_TYPE_MD5;
8145 salt_type = SALT_TYPE_INTERN;
8146 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8147 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8148 kern_type = KERN_TYPE_MD5ASA;
8149 dgst_size = DGST_SIZE_4_4;
8150 parse_func = md5asa_parse_hash;
8151 sort_by_digest = sort_by_digest_4_4;
8152 opti_type = OPTI_TYPE_ZERO_BYTE
8153 | OPTI_TYPE_PRECOMPUTE_INIT
8154 | OPTI_TYPE_PRECOMPUTE_MERKLE
8155 | OPTI_TYPE_EARLY_SKIP
8156 | OPTI_TYPE_NOT_ITERATED;
8157 dgst_pos0 = 0;
8158 dgst_pos1 = 3;
8159 dgst_pos2 = 2;
8160 dgst_pos3 = 1;
8161 break;
8162
8163 case 2500: hash_type = HASH_TYPE_WPA;
8164 salt_type = SALT_TYPE_EMBEDDED;
8165 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8166 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8167 kern_type = KERN_TYPE_WPA;
8168 dgst_size = DGST_SIZE_4_4;
8169 parse_func = wpa_parse_hash;
8170 sort_by_digest = sort_by_digest_4_4;
8171 opti_type = OPTI_TYPE_ZERO_BYTE;
8172 dgst_pos0 = 0;
8173 dgst_pos1 = 1;
8174 dgst_pos2 = 2;
8175 dgst_pos3 = 3;
8176 break;
8177
8178 case 2600: hash_type = HASH_TYPE_MD5;
8179 salt_type = SALT_TYPE_VIRTUAL;
8180 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8181 opts_type = OPTS_TYPE_PT_GENERATE_LE
8182 | OPTS_TYPE_PT_ADD80
8183 | OPTS_TYPE_PT_ADDBITS14
8184 | OPTS_TYPE_ST_ADD80;
8185 kern_type = KERN_TYPE_MD55_PWSLT1;
8186 dgst_size = DGST_SIZE_4_4;
8187 parse_func = md5md5_parse_hash;
8188 sort_by_digest = sort_by_digest_4_4;
8189 opti_type = OPTI_TYPE_ZERO_BYTE
8190 | OPTI_TYPE_PRECOMPUTE_INIT
8191 | OPTI_TYPE_PRECOMPUTE_MERKLE
8192 | OPTI_TYPE_EARLY_SKIP;
8193 dgst_pos0 = 0;
8194 dgst_pos1 = 3;
8195 dgst_pos2 = 2;
8196 dgst_pos3 = 1;
8197 break;
8198
8199 case 2611: hash_type = HASH_TYPE_MD5;
8200 salt_type = SALT_TYPE_INTERN;
8201 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8202 opts_type = OPTS_TYPE_PT_GENERATE_LE
8203 | OPTS_TYPE_PT_ADD80
8204 | OPTS_TYPE_PT_ADDBITS14
8205 | OPTS_TYPE_ST_ADD80;
8206 kern_type = KERN_TYPE_MD55_PWSLT1;
8207 dgst_size = DGST_SIZE_4_4;
8208 parse_func = vb3_parse_hash;
8209 sort_by_digest = sort_by_digest_4_4;
8210 opti_type = OPTI_TYPE_ZERO_BYTE
8211 | OPTI_TYPE_PRECOMPUTE_INIT
8212 | OPTI_TYPE_PRECOMPUTE_MERKLE
8213 | OPTI_TYPE_EARLY_SKIP;
8214 dgst_pos0 = 0;
8215 dgst_pos1 = 3;
8216 dgst_pos2 = 2;
8217 dgst_pos3 = 1;
8218 break;
8219
8220 case 2612: hash_type = HASH_TYPE_MD5;
8221 salt_type = SALT_TYPE_EMBEDDED;
8222 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8223 opts_type = OPTS_TYPE_PT_GENERATE_LE
8224 | OPTS_TYPE_PT_ADD80
8225 | OPTS_TYPE_PT_ADDBITS14
8226 | OPTS_TYPE_ST_ADD80
8227 | OPTS_TYPE_ST_HEX;
8228 kern_type = KERN_TYPE_MD55_PWSLT1;
8229 dgst_size = DGST_SIZE_4_4;
8230 parse_func = phps_parse_hash;
8231 sort_by_digest = sort_by_digest_4_4;
8232 opti_type = OPTI_TYPE_ZERO_BYTE
8233 | OPTI_TYPE_PRECOMPUTE_INIT
8234 | OPTI_TYPE_PRECOMPUTE_MERKLE
8235 | OPTI_TYPE_EARLY_SKIP;
8236 dgst_pos0 = 0;
8237 dgst_pos1 = 3;
8238 dgst_pos2 = 2;
8239 dgst_pos3 = 1;
8240 break;
8241
8242 case 2711: hash_type = HASH_TYPE_MD5;
8243 salt_type = SALT_TYPE_INTERN;
8244 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8245 opts_type = OPTS_TYPE_PT_GENERATE_LE
8246 | OPTS_TYPE_PT_ADD80
8247 | OPTS_TYPE_PT_ADDBITS14
8248 | OPTS_TYPE_ST_ADD80;
8249 kern_type = KERN_TYPE_MD55_PWSLT2;
8250 dgst_size = DGST_SIZE_4_4;
8251 parse_func = vb30_parse_hash;
8252 sort_by_digest = sort_by_digest_4_4;
8253 opti_type = OPTI_TYPE_ZERO_BYTE
8254 | OPTI_TYPE_PRECOMPUTE_INIT
8255 | OPTI_TYPE_EARLY_SKIP;
8256 dgst_pos0 = 0;
8257 dgst_pos1 = 3;
8258 dgst_pos2 = 2;
8259 dgst_pos3 = 1;
8260 break;
8261
8262 case 2811: hash_type = HASH_TYPE_MD5;
8263 salt_type = SALT_TYPE_INTERN;
8264 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8265 opts_type = OPTS_TYPE_PT_GENERATE_LE
8266 | OPTS_TYPE_PT_ADD80
8267 | OPTS_TYPE_PT_ADDBITS14;
8268 kern_type = KERN_TYPE_MD55_SLTPW;
8269 dgst_size = DGST_SIZE_4_4;
8270 parse_func = ipb2_parse_hash;
8271 sort_by_digest = sort_by_digest_4_4;
8272 opti_type = OPTI_TYPE_ZERO_BYTE
8273 | OPTI_TYPE_PRECOMPUTE_INIT
8274 | OPTI_TYPE_EARLY_SKIP;
8275 dgst_pos0 = 0;
8276 dgst_pos1 = 3;
8277 dgst_pos2 = 2;
8278 dgst_pos3 = 1;
8279 break;
8280
8281 case 3000: hash_type = HASH_TYPE_LM;
8282 salt_type = SALT_TYPE_NONE;
8283 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8284 opts_type = OPTS_TYPE_PT_GENERATE_LE
8285 | OPTS_TYPE_PT_UPPER
8286 | OPTS_TYPE_PT_BITSLICE;
8287 kern_type = KERN_TYPE_LM;
8288 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8289 parse_func = lm_parse_hash;
8290 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8291 opti_type = OPTI_TYPE_ZERO_BYTE
8292 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8293 dgst_pos0 = 0;
8294 dgst_pos1 = 1;
8295 dgst_pos2 = 2;
8296 dgst_pos3 = 3;
8297 break;
8298
8299 case 3100: hash_type = HASH_TYPE_ORACLEH;
8300 salt_type = SALT_TYPE_INTERN;
8301 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8302 opts_type = OPTS_TYPE_PT_GENERATE_LE
8303 | OPTS_TYPE_PT_UPPER
8304 | OPTS_TYPE_ST_UPPER;
8305 kern_type = KERN_TYPE_ORACLEH;
8306 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8307 parse_func = oracleh_parse_hash;
8308 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8309 opti_type = OPTI_TYPE_ZERO_BYTE;
8310 dgst_pos0 = 0;
8311 dgst_pos1 = 1;
8312 dgst_pos2 = 2;
8313 dgst_pos3 = 3;
8314 break;
8315
8316 case 3200: hash_type = HASH_TYPE_BCRYPT;
8317 salt_type = SALT_TYPE_EMBEDDED;
8318 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8319 opts_type = OPTS_TYPE_PT_GENERATE_LE
8320 | OPTS_TYPE_ST_GENERATE_LE;
8321 kern_type = KERN_TYPE_BCRYPT;
8322 dgst_size = DGST_SIZE_4_6;
8323 parse_func = bcrypt_parse_hash;
8324 sort_by_digest = sort_by_digest_4_6;
8325 opti_type = OPTI_TYPE_ZERO_BYTE;
8326 dgst_pos0 = 0;
8327 dgst_pos1 = 1;
8328 dgst_pos2 = 2;
8329 dgst_pos3 = 3;
8330 break;
8331
8332 case 3710: hash_type = HASH_TYPE_MD5;
8333 salt_type = SALT_TYPE_INTERN;
8334 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8335 opts_type = OPTS_TYPE_PT_GENERATE_LE
8336 | OPTS_TYPE_PT_ADD80
8337 | OPTS_TYPE_PT_ADDBITS14;
8338 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8339 dgst_size = DGST_SIZE_4_4;
8340 parse_func = md5s_parse_hash;
8341 sort_by_digest = sort_by_digest_4_4;
8342 opti_type = OPTI_TYPE_ZERO_BYTE
8343 | OPTI_TYPE_PRECOMPUTE_INIT
8344 | OPTI_TYPE_PRECOMPUTE_MERKLE
8345 | OPTI_TYPE_EARLY_SKIP;
8346 dgst_pos0 = 0;
8347 dgst_pos1 = 3;
8348 dgst_pos2 = 2;
8349 dgst_pos3 = 1;
8350 break;
8351
8352 case 3711: hash_type = HASH_TYPE_MD5;
8353 salt_type = SALT_TYPE_EMBEDDED;
8354 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8355 opts_type = OPTS_TYPE_PT_GENERATE_LE
8356 | OPTS_TYPE_PT_ADD80
8357 | OPTS_TYPE_PT_ADDBITS14;
8358 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8359 dgst_size = DGST_SIZE_4_4;
8360 parse_func = mediawiki_b_parse_hash;
8361 sort_by_digest = sort_by_digest_4_4;
8362 opti_type = OPTI_TYPE_ZERO_BYTE
8363 | OPTI_TYPE_PRECOMPUTE_INIT
8364 | OPTI_TYPE_PRECOMPUTE_MERKLE
8365 | OPTI_TYPE_EARLY_SKIP;
8366 dgst_pos0 = 0;
8367 dgst_pos1 = 3;
8368 dgst_pos2 = 2;
8369 dgst_pos3 = 1;
8370 break;
8371
8372 case 3800: hash_type = HASH_TYPE_MD5;
8373 salt_type = SALT_TYPE_INTERN;
8374 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8375 opts_type = OPTS_TYPE_PT_GENERATE_LE
8376 | OPTS_TYPE_ST_ADDBITS14;
8377 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8378 dgst_size = DGST_SIZE_4_4;
8379 parse_func = md5s_parse_hash;
8380 sort_by_digest = sort_by_digest_4_4;
8381 opti_type = OPTI_TYPE_ZERO_BYTE
8382 | OPTI_TYPE_PRECOMPUTE_INIT
8383 | OPTI_TYPE_PRECOMPUTE_MERKLE
8384 | OPTI_TYPE_EARLY_SKIP
8385 | OPTI_TYPE_NOT_ITERATED
8386 | OPTI_TYPE_RAW_HASH;
8387 dgst_pos0 = 0;
8388 dgst_pos1 = 3;
8389 dgst_pos2 = 2;
8390 dgst_pos3 = 1;
8391 break;
8392
8393 case 4300: hash_type = HASH_TYPE_MD5;
8394 salt_type = SALT_TYPE_VIRTUAL;
8395 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8396 opts_type = OPTS_TYPE_PT_GENERATE_LE
8397 | OPTS_TYPE_PT_ADD80
8398 | OPTS_TYPE_PT_ADDBITS14
8399 | OPTS_TYPE_ST_ADD80;
8400 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8401 dgst_size = DGST_SIZE_4_4;
8402 parse_func = md5md5_parse_hash;
8403 sort_by_digest = sort_by_digest_4_4;
8404 opti_type = OPTI_TYPE_ZERO_BYTE
8405 | OPTI_TYPE_PRECOMPUTE_INIT
8406 | OPTI_TYPE_PRECOMPUTE_MERKLE
8407 | OPTI_TYPE_EARLY_SKIP;
8408 dgst_pos0 = 0;
8409 dgst_pos1 = 3;
8410 dgst_pos2 = 2;
8411 dgst_pos3 = 1;
8412 break;
8413
8414
8415 case 4400: hash_type = HASH_TYPE_MD5;
8416 salt_type = SALT_TYPE_NONE;
8417 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8418 opts_type = OPTS_TYPE_PT_GENERATE_BE
8419 | OPTS_TYPE_PT_ADD80
8420 | OPTS_TYPE_PT_ADDBITS15;
8421 kern_type = KERN_TYPE_MD5_SHA1;
8422 dgst_size = DGST_SIZE_4_4;
8423 parse_func = md5_parse_hash;
8424 sort_by_digest = sort_by_digest_4_4;
8425 opti_type = OPTI_TYPE_ZERO_BYTE
8426 | OPTI_TYPE_PRECOMPUTE_INIT
8427 | OPTI_TYPE_PRECOMPUTE_MERKLE
8428 | OPTI_TYPE_EARLY_SKIP
8429 | OPTI_TYPE_NOT_ITERATED
8430 | OPTI_TYPE_NOT_SALTED
8431 | OPTI_TYPE_RAW_HASH;
8432 dgst_pos0 = 0;
8433 dgst_pos1 = 3;
8434 dgst_pos2 = 2;
8435 dgst_pos3 = 1;
8436 break;
8437
8438 case 4500: hash_type = HASH_TYPE_SHA1;
8439 salt_type = SALT_TYPE_NONE;
8440 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8441 opts_type = OPTS_TYPE_PT_GENERATE_BE
8442 | OPTS_TYPE_PT_ADD80
8443 | OPTS_TYPE_PT_ADDBITS15;
8444 kern_type = KERN_TYPE_SHA11;
8445 dgst_size = DGST_SIZE_4_5;
8446 parse_func = sha1_parse_hash;
8447 sort_by_digest = sort_by_digest_4_5;
8448 opti_type = OPTI_TYPE_ZERO_BYTE
8449 | OPTI_TYPE_PRECOMPUTE_INIT
8450 | OPTI_TYPE_PRECOMPUTE_MERKLE
8451 | OPTI_TYPE_EARLY_SKIP
8452 | OPTI_TYPE_NOT_SALTED;
8453 dgst_pos0 = 3;
8454 dgst_pos1 = 4;
8455 dgst_pos2 = 2;
8456 dgst_pos3 = 1;
8457 break;
8458
8459 case 4700: hash_type = HASH_TYPE_SHA1;
8460 salt_type = SALT_TYPE_NONE;
8461 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8462 opts_type = OPTS_TYPE_PT_GENERATE_LE
8463 | OPTS_TYPE_PT_ADD80
8464 | OPTS_TYPE_PT_ADDBITS14;
8465 kern_type = KERN_TYPE_SHA1_MD5;
8466 dgst_size = DGST_SIZE_4_5;
8467 parse_func = sha1_parse_hash;
8468 sort_by_digest = sort_by_digest_4_5;
8469 opti_type = OPTI_TYPE_ZERO_BYTE
8470 | OPTI_TYPE_PRECOMPUTE_INIT
8471 | OPTI_TYPE_PRECOMPUTE_MERKLE
8472 | OPTI_TYPE_EARLY_SKIP
8473 | OPTI_TYPE_NOT_ITERATED
8474 | OPTI_TYPE_NOT_SALTED
8475 | OPTI_TYPE_RAW_HASH;
8476 dgst_pos0 = 3;
8477 dgst_pos1 = 4;
8478 dgst_pos2 = 2;
8479 dgst_pos3 = 1;
8480 break;
8481
8482 case 4800: hash_type = HASH_TYPE_MD5;
8483 salt_type = SALT_TYPE_EMBEDDED;
8484 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8485 opts_type = OPTS_TYPE_PT_GENERATE_LE
8486 | OPTS_TYPE_PT_ADDBITS14;
8487 kern_type = KERN_TYPE_MD5_CHAP;
8488 dgst_size = DGST_SIZE_4_4;
8489 parse_func = chap_parse_hash;
8490 sort_by_digest = sort_by_digest_4_4;
8491 opti_type = OPTI_TYPE_ZERO_BYTE
8492 | OPTI_TYPE_PRECOMPUTE_INIT
8493 | OPTI_TYPE_PRECOMPUTE_MERKLE
8494 | OPTI_TYPE_MEET_IN_MIDDLE
8495 | OPTI_TYPE_EARLY_SKIP
8496 | OPTI_TYPE_NOT_ITERATED
8497 | OPTI_TYPE_RAW_HASH;
8498 dgst_pos0 = 0;
8499 dgst_pos1 = 3;
8500 dgst_pos2 = 2;
8501 dgst_pos3 = 1;
8502 break;
8503
8504 case 4900: hash_type = HASH_TYPE_SHA1;
8505 salt_type = SALT_TYPE_INTERN;
8506 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8507 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8508 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8509 dgst_size = DGST_SIZE_4_5;
8510 parse_func = sha1s_parse_hash;
8511 sort_by_digest = sort_by_digest_4_5;
8512 opti_type = OPTI_TYPE_ZERO_BYTE
8513 | OPTI_TYPE_PRECOMPUTE_INIT
8514 | OPTI_TYPE_PRECOMPUTE_MERKLE
8515 | OPTI_TYPE_EARLY_SKIP;
8516 dgst_pos0 = 3;
8517 dgst_pos1 = 4;
8518 dgst_pos2 = 2;
8519 dgst_pos3 = 1;
8520 break;
8521
8522 case 5000: hash_type = HASH_TYPE_KECCAK;
8523 salt_type = SALT_TYPE_EMBEDDED;
8524 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8525 opts_type = OPTS_TYPE_PT_GENERATE_LE
8526 | OPTS_TYPE_PT_ADD01;
8527 kern_type = KERN_TYPE_KECCAK;
8528 dgst_size = DGST_SIZE_8_25;
8529 parse_func = keccak_parse_hash;
8530 sort_by_digest = sort_by_digest_8_25;
8531 opti_type = OPTI_TYPE_ZERO_BYTE
8532 | OPTI_TYPE_USES_BITS_64
8533 | OPTI_TYPE_RAW_HASH;
8534 dgst_pos0 = 2;
8535 dgst_pos1 = 3;
8536 dgst_pos2 = 4;
8537 dgst_pos3 = 5;
8538 break;
8539
8540 case 5100: hash_type = HASH_TYPE_MD5H;
8541 salt_type = SALT_TYPE_NONE;
8542 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8543 opts_type = OPTS_TYPE_PT_GENERATE_LE
8544 | OPTS_TYPE_PT_ADD80
8545 | OPTS_TYPE_PT_ADDBITS14;
8546 kern_type = KERN_TYPE_MD5H;
8547 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8548 parse_func = md5half_parse_hash;
8549 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8550 opti_type = OPTI_TYPE_ZERO_BYTE
8551 | OPTI_TYPE_RAW_HASH;
8552 dgst_pos0 = 0;
8553 dgst_pos1 = 1;
8554 dgst_pos2 = 2;
8555 dgst_pos3 = 3;
8556 break;
8557
8558 case 5200: hash_type = HASH_TYPE_SHA256;
8559 salt_type = SALT_TYPE_EMBEDDED;
8560 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8561 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8562 kern_type = KERN_TYPE_PSAFE3;
8563 dgst_size = DGST_SIZE_4_8;
8564 parse_func = psafe3_parse_hash;
8565 sort_by_digest = sort_by_digest_4_8;
8566 opti_type = OPTI_TYPE_ZERO_BYTE;
8567 dgst_pos0 = 0;
8568 dgst_pos1 = 1;
8569 dgst_pos2 = 2;
8570 dgst_pos3 = 3;
8571 break;
8572
8573 case 5300: hash_type = HASH_TYPE_MD5;
8574 salt_type = SALT_TYPE_EMBEDDED;
8575 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8576 opts_type = OPTS_TYPE_PT_GENERATE_LE
8577 | OPTS_TYPE_ST_ADD80;
8578 kern_type = KERN_TYPE_IKEPSK_MD5;
8579 dgst_size = DGST_SIZE_4_4;
8580 parse_func = ikepsk_md5_parse_hash;
8581 sort_by_digest = sort_by_digest_4_4;
8582 opti_type = OPTI_TYPE_ZERO_BYTE;
8583 dgst_pos0 = 0;
8584 dgst_pos1 = 3;
8585 dgst_pos2 = 2;
8586 dgst_pos3 = 1;
8587 break;
8588
8589 case 5400: hash_type = HASH_TYPE_SHA1;
8590 salt_type = SALT_TYPE_EMBEDDED;
8591 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8592 opts_type = OPTS_TYPE_PT_GENERATE_BE
8593 | OPTS_TYPE_ST_ADD80;
8594 kern_type = KERN_TYPE_IKEPSK_SHA1;
8595 dgst_size = DGST_SIZE_4_5;
8596 parse_func = ikepsk_sha1_parse_hash;
8597 sort_by_digest = sort_by_digest_4_5;
8598 opti_type = OPTI_TYPE_ZERO_BYTE;
8599 dgst_pos0 = 3;
8600 dgst_pos1 = 4;
8601 dgst_pos2 = 2;
8602 dgst_pos3 = 1;
8603 break;
8604
8605 case 5500: hash_type = HASH_TYPE_NETNTLM;
8606 salt_type = SALT_TYPE_EMBEDDED;
8607 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8608 opts_type = OPTS_TYPE_PT_GENERATE_LE
8609 | OPTS_TYPE_PT_ADD80
8610 | OPTS_TYPE_PT_ADDBITS14
8611 | OPTS_TYPE_PT_UNICODE
8612 | OPTS_TYPE_ST_HEX;
8613 kern_type = KERN_TYPE_NETNTLMv1;
8614 dgst_size = DGST_SIZE_4_4;
8615 parse_func = netntlmv1_parse_hash;
8616 sort_by_digest = sort_by_digest_4_4;
8617 opti_type = OPTI_TYPE_ZERO_BYTE
8618 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8619 dgst_pos0 = 0;
8620 dgst_pos1 = 1;
8621 dgst_pos2 = 2;
8622 dgst_pos3 = 3;
8623 break;
8624
8625 case 5600: hash_type = HASH_TYPE_MD5;
8626 salt_type = SALT_TYPE_EMBEDDED;
8627 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8628 opts_type = OPTS_TYPE_PT_GENERATE_LE
8629 | OPTS_TYPE_PT_ADD80
8630 | OPTS_TYPE_PT_ADDBITS14
8631 | OPTS_TYPE_PT_UNICODE;
8632 kern_type = KERN_TYPE_NETNTLMv2;
8633 dgst_size = DGST_SIZE_4_4;
8634 parse_func = netntlmv2_parse_hash;
8635 sort_by_digest = sort_by_digest_4_4;
8636 opti_type = OPTI_TYPE_ZERO_BYTE;
8637 dgst_pos0 = 0;
8638 dgst_pos1 = 3;
8639 dgst_pos2 = 2;
8640 dgst_pos3 = 1;
8641 break;
8642
8643 case 5700: hash_type = HASH_TYPE_SHA256;
8644 salt_type = SALT_TYPE_NONE;
8645 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8646 opts_type = OPTS_TYPE_PT_GENERATE_BE
8647 | OPTS_TYPE_PT_ADD80
8648 | OPTS_TYPE_PT_ADDBITS15;
8649 kern_type = KERN_TYPE_SHA256;
8650 dgst_size = DGST_SIZE_4_8;
8651 parse_func = cisco4_parse_hash;
8652 sort_by_digest = sort_by_digest_4_8;
8653 opti_type = OPTI_TYPE_ZERO_BYTE
8654 | OPTI_TYPE_PRECOMPUTE_INIT
8655 | OPTI_TYPE_PRECOMPUTE_MERKLE
8656 | OPTI_TYPE_EARLY_SKIP
8657 | OPTI_TYPE_NOT_ITERATED
8658 | OPTI_TYPE_NOT_SALTED
8659 | OPTI_TYPE_RAW_HASH;
8660 dgst_pos0 = 3;
8661 dgst_pos1 = 7;
8662 dgst_pos2 = 2;
8663 dgst_pos3 = 6;
8664 break;
8665
8666 case 5800: hash_type = HASH_TYPE_SHA1;
8667 salt_type = SALT_TYPE_INTERN;
8668 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8669 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8670 | OPTS_TYPE_ST_ADD80;
8671 kern_type = KERN_TYPE_ANDROIDPIN;
8672 dgst_size = DGST_SIZE_4_5;
8673 parse_func = androidpin_parse_hash;
8674 sort_by_digest = sort_by_digest_4_5;
8675 opti_type = OPTI_TYPE_ZERO_BYTE;
8676 dgst_pos0 = 0;
8677 dgst_pos1 = 1;
8678 dgst_pos2 = 2;
8679 dgst_pos3 = 3;
8680 break;
8681
8682 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8683 salt_type = SALT_TYPE_NONE;
8684 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8685 opts_type = OPTS_TYPE_PT_GENERATE_LE
8686 | OPTS_TYPE_PT_ADD80;
8687 kern_type = KERN_TYPE_RIPEMD160;
8688 dgst_size = DGST_SIZE_4_5;
8689 parse_func = ripemd160_parse_hash;
8690 sort_by_digest = sort_by_digest_4_5;
8691 opti_type = OPTI_TYPE_ZERO_BYTE;
8692 dgst_pos0 = 0;
8693 dgst_pos1 = 1;
8694 dgst_pos2 = 2;
8695 dgst_pos3 = 3;
8696 break;
8697
8698 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8699 salt_type = SALT_TYPE_NONE;
8700 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8701 opts_type = OPTS_TYPE_PT_GENERATE_BE
8702 | OPTS_TYPE_PT_ADD80;
8703 kern_type = KERN_TYPE_WHIRLPOOL;
8704 dgst_size = DGST_SIZE_4_16;
8705 parse_func = whirlpool_parse_hash;
8706 sort_by_digest = sort_by_digest_4_16;
8707 opti_type = OPTI_TYPE_ZERO_BYTE;
8708 dgst_pos0 = 0;
8709 dgst_pos1 = 1;
8710 dgst_pos2 = 2;
8711 dgst_pos3 = 3;
8712 break;
8713
8714 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8715 salt_type = SALT_TYPE_EMBEDDED;
8716 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8717 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8718 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8719 dgst_size = DGST_SIZE_4_5;
8720 parse_func = truecrypt_parse_hash_2k;
8721 sort_by_digest = sort_by_digest_4_5;
8722 opti_type = OPTI_TYPE_ZERO_BYTE;
8723 dgst_pos0 = 0;
8724 dgst_pos1 = 1;
8725 dgst_pos2 = 2;
8726 dgst_pos3 = 3;
8727 break;
8728
8729 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8730 salt_type = SALT_TYPE_EMBEDDED;
8731 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8732 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8733 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8734 dgst_size = DGST_SIZE_4_5;
8735 parse_func = truecrypt_parse_hash_2k;
8736 sort_by_digest = sort_by_digest_4_5;
8737 opti_type = OPTI_TYPE_ZERO_BYTE;
8738 dgst_pos0 = 0;
8739 dgst_pos1 = 1;
8740 dgst_pos2 = 2;
8741 dgst_pos3 = 3;
8742 break;
8743
8744 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8745 salt_type = SALT_TYPE_EMBEDDED;
8746 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8747 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8748 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8749 dgst_size = DGST_SIZE_4_5;
8750 parse_func = truecrypt_parse_hash_2k;
8751 sort_by_digest = sort_by_digest_4_5;
8752 opti_type = OPTI_TYPE_ZERO_BYTE;
8753 dgst_pos0 = 0;
8754 dgst_pos1 = 1;
8755 dgst_pos2 = 2;
8756 dgst_pos3 = 3;
8757 break;
8758
8759 case 6221: hash_type = HASH_TYPE_SHA512;
8760 salt_type = SALT_TYPE_EMBEDDED;
8761 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8762 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8763 kern_type = KERN_TYPE_TCSHA512_XTS512;
8764 dgst_size = DGST_SIZE_8_8;
8765 parse_func = truecrypt_parse_hash_1k;
8766 sort_by_digest = sort_by_digest_8_8;
8767 opti_type = OPTI_TYPE_ZERO_BYTE
8768 | OPTI_TYPE_USES_BITS_64;
8769 dgst_pos0 = 0;
8770 dgst_pos1 = 1;
8771 dgst_pos2 = 2;
8772 dgst_pos3 = 3;
8773 break;
8774
8775 case 6222: hash_type = HASH_TYPE_SHA512;
8776 salt_type = SALT_TYPE_EMBEDDED;
8777 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8778 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8779 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8780 dgst_size = DGST_SIZE_8_8;
8781 parse_func = truecrypt_parse_hash_1k;
8782 sort_by_digest = sort_by_digest_8_8;
8783 opti_type = OPTI_TYPE_ZERO_BYTE
8784 | OPTI_TYPE_USES_BITS_64;
8785 dgst_pos0 = 0;
8786 dgst_pos1 = 1;
8787 dgst_pos2 = 2;
8788 dgst_pos3 = 3;
8789 break;
8790
8791 case 6223: hash_type = HASH_TYPE_SHA512;
8792 salt_type = SALT_TYPE_EMBEDDED;
8793 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8794 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8795 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8796 dgst_size = DGST_SIZE_8_8;
8797 parse_func = truecrypt_parse_hash_1k;
8798 sort_by_digest = sort_by_digest_8_8;
8799 opti_type = OPTI_TYPE_ZERO_BYTE
8800 | OPTI_TYPE_USES_BITS_64;
8801 dgst_pos0 = 0;
8802 dgst_pos1 = 1;
8803 dgst_pos2 = 2;
8804 dgst_pos3 = 3;
8805 break;
8806
8807 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8808 salt_type = SALT_TYPE_EMBEDDED;
8809 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8810 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8811 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8812 dgst_size = DGST_SIZE_4_8;
8813 parse_func = truecrypt_parse_hash_1k;
8814 sort_by_digest = sort_by_digest_4_8;
8815 opti_type = OPTI_TYPE_ZERO_BYTE;
8816 dgst_pos0 = 0;
8817 dgst_pos1 = 1;
8818 dgst_pos2 = 2;
8819 dgst_pos3 = 3;
8820 break;
8821
8822 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8823 salt_type = SALT_TYPE_EMBEDDED;
8824 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8825 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8826 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8827 dgst_size = DGST_SIZE_4_8;
8828 parse_func = truecrypt_parse_hash_1k;
8829 sort_by_digest = sort_by_digest_4_8;
8830 opti_type = OPTI_TYPE_ZERO_BYTE;
8831 dgst_pos0 = 0;
8832 dgst_pos1 = 1;
8833 dgst_pos2 = 2;
8834 dgst_pos3 = 3;
8835 break;
8836
8837 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8838 salt_type = SALT_TYPE_EMBEDDED;
8839 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8840 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8841 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8842 dgst_size = DGST_SIZE_4_8;
8843 parse_func = truecrypt_parse_hash_1k;
8844 sort_by_digest = sort_by_digest_4_8;
8845 opti_type = OPTI_TYPE_ZERO_BYTE;
8846 dgst_pos0 = 0;
8847 dgst_pos1 = 1;
8848 dgst_pos2 = 2;
8849 dgst_pos3 = 3;
8850 break;
8851
8852 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8853 salt_type = SALT_TYPE_EMBEDDED;
8854 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8855 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8856 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8857 dgst_size = DGST_SIZE_4_5;
8858 parse_func = truecrypt_parse_hash_1k;
8859 sort_by_digest = sort_by_digest_4_5;
8860 opti_type = OPTI_TYPE_ZERO_BYTE;
8861 dgst_pos0 = 0;
8862 dgst_pos1 = 1;
8863 dgst_pos2 = 2;
8864 dgst_pos3 = 3;
8865 break;
8866
8867 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8868 salt_type = SALT_TYPE_EMBEDDED;
8869 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8870 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8871 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8872 dgst_size = DGST_SIZE_4_5;
8873 parse_func = truecrypt_parse_hash_1k;
8874 sort_by_digest = sort_by_digest_4_5;
8875 opti_type = OPTI_TYPE_ZERO_BYTE;
8876 dgst_pos0 = 0;
8877 dgst_pos1 = 1;
8878 dgst_pos2 = 2;
8879 dgst_pos3 = 3;
8880 break;
8881
8882 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8883 salt_type = SALT_TYPE_EMBEDDED;
8884 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8885 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8886 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8887 dgst_size = DGST_SIZE_4_5;
8888 parse_func = truecrypt_parse_hash_1k;
8889 sort_by_digest = sort_by_digest_4_5;
8890 opti_type = OPTI_TYPE_ZERO_BYTE;
8891 dgst_pos0 = 0;
8892 dgst_pos1 = 1;
8893 dgst_pos2 = 2;
8894 dgst_pos3 = 3;
8895 break;
8896
8897 case 6300: hash_type = HASH_TYPE_MD5;
8898 salt_type = SALT_TYPE_EMBEDDED;
8899 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8900 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8901 kern_type = KERN_TYPE_MD5AIX;
8902 dgst_size = DGST_SIZE_4_4;
8903 parse_func = md5aix_parse_hash;
8904 sort_by_digest = sort_by_digest_4_4;
8905 opti_type = OPTI_TYPE_ZERO_BYTE;
8906 dgst_pos0 = 0;
8907 dgst_pos1 = 1;
8908 dgst_pos2 = 2;
8909 dgst_pos3 = 3;
8910 break;
8911
8912 case 6400: hash_type = HASH_TYPE_SHA256;
8913 salt_type = SALT_TYPE_EMBEDDED;
8914 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8915 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8916 kern_type = KERN_TYPE_SHA256AIX;
8917 dgst_size = DGST_SIZE_4_8;
8918 parse_func = sha256aix_parse_hash;
8919 sort_by_digest = sort_by_digest_4_8;
8920 opti_type = OPTI_TYPE_ZERO_BYTE;
8921 dgst_pos0 = 0;
8922 dgst_pos1 = 1;
8923 dgst_pos2 = 2;
8924 dgst_pos3 = 3;
8925 break;
8926
8927 case 6500: hash_type = HASH_TYPE_SHA512;
8928 salt_type = SALT_TYPE_EMBEDDED;
8929 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8930 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8931 kern_type = KERN_TYPE_SHA512AIX;
8932 dgst_size = DGST_SIZE_8_8;
8933 parse_func = sha512aix_parse_hash;
8934 sort_by_digest = sort_by_digest_8_8;
8935 opti_type = OPTI_TYPE_ZERO_BYTE
8936 | OPTI_TYPE_USES_BITS_64;
8937 dgst_pos0 = 0;
8938 dgst_pos1 = 1;
8939 dgst_pos2 = 2;
8940 dgst_pos3 = 3;
8941 break;
8942
8943 case 6600: hash_type = HASH_TYPE_AES;
8944 salt_type = SALT_TYPE_EMBEDDED;
8945 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8946 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8947 kern_type = KERN_TYPE_AGILEKEY;
8948 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
8949 parse_func = agilekey_parse_hash;
8950 sort_by_digest = sort_by_digest_4_5;
8951 opti_type = OPTI_TYPE_ZERO_BYTE;
8952 dgst_pos0 = 0;
8953 dgst_pos1 = 1;
8954 dgst_pos2 = 2;
8955 dgst_pos3 = 3;
8956 break;
8957
8958 case 6700: hash_type = HASH_TYPE_SHA1;
8959 salt_type = SALT_TYPE_EMBEDDED;
8960 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8961 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8962 kern_type = KERN_TYPE_SHA1AIX;
8963 dgst_size = DGST_SIZE_4_5;
8964 parse_func = sha1aix_parse_hash;
8965 sort_by_digest = sort_by_digest_4_5;
8966 opti_type = OPTI_TYPE_ZERO_BYTE;
8967 dgst_pos0 = 0;
8968 dgst_pos1 = 1;
8969 dgst_pos2 = 2;
8970 dgst_pos3 = 3;
8971 break;
8972
8973 case 6800: hash_type = HASH_TYPE_AES;
8974 salt_type = SALT_TYPE_EMBEDDED;
8975 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8976 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8977 kern_type = KERN_TYPE_LASTPASS;
8978 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
8979 parse_func = lastpass_parse_hash;
8980 sort_by_digest = sort_by_digest_4_8;
8981 opti_type = OPTI_TYPE_ZERO_BYTE;
8982 dgst_pos0 = 0;
8983 dgst_pos1 = 1;
8984 dgst_pos2 = 2;
8985 dgst_pos3 = 3;
8986 break;
8987
8988 case 6900: hash_type = HASH_TYPE_GOST;
8989 salt_type = SALT_TYPE_NONE;
8990 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8991 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8992 kern_type = KERN_TYPE_GOST;
8993 dgst_size = DGST_SIZE_4_8;
8994 parse_func = gost_parse_hash;
8995 sort_by_digest = sort_by_digest_4_8;
8996 opti_type = OPTI_TYPE_ZERO_BYTE;
8997 dgst_pos0 = 0;
8998 dgst_pos1 = 1;
8999 dgst_pos2 = 2;
9000 dgst_pos3 = 3;
9001 break;
9002
9003 case 7100: hash_type = HASH_TYPE_SHA512;
9004 salt_type = SALT_TYPE_EMBEDDED;
9005 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9006 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9007 kern_type = KERN_TYPE_PBKDF2_SHA512;
9008 dgst_size = DGST_SIZE_8_16;
9009 parse_func = sha512osx_parse_hash;
9010 sort_by_digest = sort_by_digest_8_16;
9011 opti_type = OPTI_TYPE_ZERO_BYTE
9012 | OPTI_TYPE_USES_BITS_64;
9013 dgst_pos0 = 0;
9014 dgst_pos1 = 1;
9015 dgst_pos2 = 2;
9016 dgst_pos3 = 3;
9017 break;
9018
9019 case 7200: hash_type = HASH_TYPE_SHA512;
9020 salt_type = SALT_TYPE_EMBEDDED;
9021 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9022 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9023 kern_type = KERN_TYPE_PBKDF2_SHA512;
9024 dgst_size = DGST_SIZE_8_16;
9025 parse_func = sha512grub_parse_hash;
9026 sort_by_digest = sort_by_digest_8_16;
9027 opti_type = OPTI_TYPE_ZERO_BYTE
9028 | OPTI_TYPE_USES_BITS_64;
9029 dgst_pos0 = 0;
9030 dgst_pos1 = 1;
9031 dgst_pos2 = 2;
9032 dgst_pos3 = 3;
9033 break;
9034
9035 case 7300: hash_type = HASH_TYPE_SHA1;
9036 salt_type = SALT_TYPE_EMBEDDED;
9037 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9038 opts_type = OPTS_TYPE_PT_GENERATE_BE
9039 | OPTS_TYPE_ST_ADD80
9040 | OPTS_TYPE_ST_ADDBITS15;
9041 kern_type = KERN_TYPE_RAKP;
9042 dgst_size = DGST_SIZE_4_5;
9043 parse_func = rakp_parse_hash;
9044 sort_by_digest = sort_by_digest_4_5;
9045 opti_type = OPTI_TYPE_ZERO_BYTE
9046 | OPTI_TYPE_NOT_ITERATED;
9047 dgst_pos0 = 3;
9048 dgst_pos1 = 4;
9049 dgst_pos2 = 2;
9050 dgst_pos3 = 1;
9051 break;
9052
9053 case 7400: hash_type = HASH_TYPE_SHA256;
9054 salt_type = SALT_TYPE_EMBEDDED;
9055 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9056 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9057 kern_type = KERN_TYPE_SHA256CRYPT;
9058 dgst_size = DGST_SIZE_4_8;
9059 parse_func = sha256crypt_parse_hash;
9060 sort_by_digest = sort_by_digest_4_8;
9061 opti_type = OPTI_TYPE_ZERO_BYTE;
9062 dgst_pos0 = 0;
9063 dgst_pos1 = 1;
9064 dgst_pos2 = 2;
9065 dgst_pos3 = 3;
9066 break;
9067
9068 case 7500: hash_type = HASH_TYPE_KRB5PA;
9069 salt_type = SALT_TYPE_EMBEDDED;
9070 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9071 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9072 kern_type = KERN_TYPE_KRB5PA;
9073 dgst_size = DGST_SIZE_4_4;
9074 parse_func = krb5pa_parse_hash;
9075 sort_by_digest = sort_by_digest_4_4;
9076 opti_type = OPTI_TYPE_ZERO_BYTE
9077 | OPTI_TYPE_NOT_ITERATED;
9078 dgst_pos0 = 0;
9079 dgst_pos1 = 1;
9080 dgst_pos2 = 2;
9081 dgst_pos3 = 3;
9082 break;
9083
9084 case 7600: hash_type = HASH_TYPE_SHA1;
9085 salt_type = SALT_TYPE_INTERN;
9086 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9087 opts_type = OPTS_TYPE_PT_GENERATE_BE
9088 | OPTS_TYPE_PT_ADD80
9089 | OPTS_TYPE_PT_ADDBITS15;
9090 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9091 dgst_size = DGST_SIZE_4_5;
9092 parse_func = redmine_parse_hash;
9093 sort_by_digest = sort_by_digest_4_5;
9094 opti_type = OPTI_TYPE_ZERO_BYTE
9095 | OPTI_TYPE_PRECOMPUTE_INIT
9096 | OPTI_TYPE_EARLY_SKIP
9097 | OPTI_TYPE_NOT_ITERATED
9098 | OPTI_TYPE_PREPENDED_SALT;
9099 dgst_pos0 = 3;
9100 dgst_pos1 = 4;
9101 dgst_pos2 = 2;
9102 dgst_pos3 = 1;
9103 break;
9104
9105 case 7700: hash_type = HASH_TYPE_SAPB;
9106 salt_type = SALT_TYPE_EMBEDDED;
9107 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9108 opts_type = OPTS_TYPE_PT_GENERATE_LE
9109 | OPTS_TYPE_PT_UPPER
9110 | OPTS_TYPE_ST_UPPER;
9111 kern_type = KERN_TYPE_SAPB;
9112 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9113 parse_func = sapb_parse_hash;
9114 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9115 opti_type = OPTI_TYPE_ZERO_BYTE
9116 | OPTI_TYPE_PRECOMPUTE_INIT
9117 | OPTI_TYPE_NOT_ITERATED;
9118 dgst_pos0 = 0;
9119 dgst_pos1 = 1;
9120 dgst_pos2 = 2;
9121 dgst_pos3 = 3;
9122 break;
9123
9124 case 7800: hash_type = HASH_TYPE_SAPG;
9125 salt_type = SALT_TYPE_EMBEDDED;
9126 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9127 opts_type = OPTS_TYPE_PT_GENERATE_BE
9128 | OPTS_TYPE_ST_ADD80
9129 | OPTS_TYPE_ST_UPPER;
9130 kern_type = KERN_TYPE_SAPG;
9131 dgst_size = DGST_SIZE_4_5;
9132 parse_func = sapg_parse_hash;
9133 sort_by_digest = sort_by_digest_4_5;
9134 opti_type = OPTI_TYPE_ZERO_BYTE
9135 | OPTI_TYPE_PRECOMPUTE_INIT
9136 | OPTI_TYPE_NOT_ITERATED;
9137 dgst_pos0 = 3;
9138 dgst_pos1 = 4;
9139 dgst_pos2 = 2;
9140 dgst_pos3 = 1;
9141 break;
9142
9143 case 7900: hash_type = HASH_TYPE_SHA512;
9144 salt_type = SALT_TYPE_EMBEDDED;
9145 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9146 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9147 kern_type = KERN_TYPE_DRUPAL7;
9148 dgst_size = DGST_SIZE_8_8;
9149 parse_func = drupal7_parse_hash;
9150 sort_by_digest = sort_by_digest_8_8;
9151 opti_type = OPTI_TYPE_ZERO_BYTE
9152 | OPTI_TYPE_USES_BITS_64;
9153 dgst_pos0 = 0;
9154 dgst_pos1 = 1;
9155 dgst_pos2 = 2;
9156 dgst_pos3 = 3;
9157 break;
9158
9159 case 8000: hash_type = HASH_TYPE_SHA256;
9160 salt_type = SALT_TYPE_EMBEDDED;
9161 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9162 opts_type = OPTS_TYPE_PT_GENERATE_BE
9163 | OPTS_TYPE_PT_UNICODE
9164 | OPTS_TYPE_ST_ADD80
9165 | OPTS_TYPE_ST_HEX;
9166 kern_type = KERN_TYPE_SYBASEASE;
9167 dgst_size = DGST_SIZE_4_8;
9168 parse_func = sybasease_parse_hash;
9169 sort_by_digest = sort_by_digest_4_8;
9170 opti_type = OPTI_TYPE_ZERO_BYTE
9171 | OPTI_TYPE_PRECOMPUTE_INIT
9172 | OPTI_TYPE_EARLY_SKIP
9173 | OPTI_TYPE_NOT_ITERATED
9174 | OPTI_TYPE_RAW_HASH;
9175 dgst_pos0 = 3;
9176 dgst_pos1 = 7;
9177 dgst_pos2 = 2;
9178 dgst_pos3 = 6;
9179 break;
9180
9181 case 8100: hash_type = HASH_TYPE_SHA1;
9182 salt_type = SALT_TYPE_EMBEDDED;
9183 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9184 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9185 kern_type = KERN_TYPE_NETSCALER;
9186 dgst_size = DGST_SIZE_4_5;
9187 parse_func = netscaler_parse_hash;
9188 sort_by_digest = sort_by_digest_4_5;
9189 opti_type = OPTI_TYPE_ZERO_BYTE
9190 | OPTI_TYPE_PRECOMPUTE_INIT
9191 | OPTI_TYPE_PRECOMPUTE_MERKLE
9192 | OPTI_TYPE_EARLY_SKIP
9193 | OPTI_TYPE_NOT_ITERATED
9194 | OPTI_TYPE_PREPENDED_SALT
9195 | OPTI_TYPE_RAW_HASH;
9196 dgst_pos0 = 3;
9197 dgst_pos1 = 4;
9198 dgst_pos2 = 2;
9199 dgst_pos3 = 1;
9200 break;
9201
9202 case 8200: hash_type = HASH_TYPE_SHA256;
9203 salt_type = SALT_TYPE_EMBEDDED;
9204 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9205 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9206 kern_type = KERN_TYPE_CLOUDKEY;
9207 dgst_size = DGST_SIZE_4_8;
9208 parse_func = cloudkey_parse_hash;
9209 sort_by_digest = sort_by_digest_4_8;
9210 opti_type = OPTI_TYPE_ZERO_BYTE;
9211 dgst_pos0 = 0;
9212 dgst_pos1 = 1;
9213 dgst_pos2 = 2;
9214 dgst_pos3 = 3;
9215 break;
9216
9217 case 8300: hash_type = HASH_TYPE_SHA1;
9218 salt_type = SALT_TYPE_EMBEDDED;
9219 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9220 opts_type = OPTS_TYPE_PT_GENERATE_BE
9221 | OPTS_TYPE_ST_HEX
9222 | OPTS_TYPE_ST_ADD80;
9223 kern_type = KERN_TYPE_NSEC3;
9224 dgst_size = DGST_SIZE_4_5;
9225 parse_func = nsec3_parse_hash;
9226 sort_by_digest = sort_by_digest_4_5;
9227 opti_type = OPTI_TYPE_ZERO_BYTE;
9228 dgst_pos0 = 3;
9229 dgst_pos1 = 4;
9230 dgst_pos2 = 2;
9231 dgst_pos3 = 1;
9232 break;
9233
9234 case 8400: hash_type = HASH_TYPE_SHA1;
9235 salt_type = SALT_TYPE_INTERN;
9236 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9237 opts_type = OPTS_TYPE_PT_GENERATE_BE
9238 | OPTS_TYPE_PT_ADD80
9239 | OPTS_TYPE_PT_ADDBITS15;
9240 kern_type = KERN_TYPE_WBB3;
9241 dgst_size = DGST_SIZE_4_5;
9242 parse_func = wbb3_parse_hash;
9243 sort_by_digest = sort_by_digest_4_5;
9244 opti_type = OPTI_TYPE_ZERO_BYTE
9245 | OPTI_TYPE_PRECOMPUTE_INIT
9246 | OPTI_TYPE_NOT_ITERATED;
9247 dgst_pos0 = 3;
9248 dgst_pos1 = 4;
9249 dgst_pos2 = 2;
9250 dgst_pos3 = 1;
9251 break;
9252
9253 case 8500: hash_type = HASH_TYPE_DESRACF;
9254 salt_type = SALT_TYPE_EMBEDDED;
9255 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9256 opts_type = OPTS_TYPE_PT_GENERATE_LE
9257 | OPTS_TYPE_ST_UPPER;
9258 kern_type = KERN_TYPE_RACF;
9259 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9260 parse_func = racf_parse_hash;
9261 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9262 opti_type = OPTI_TYPE_ZERO_BYTE
9263 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9264 dgst_pos0 = 0;
9265 dgst_pos1 = 1;
9266 dgst_pos2 = 2;
9267 dgst_pos3 = 3;
9268 break;
9269
9270 case 8600: hash_type = HASH_TYPE_LOTUS5;
9271 salt_type = SALT_TYPE_NONE;
9272 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9273 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9274 kern_type = KERN_TYPE_LOTUS5;
9275 dgst_size = DGST_SIZE_4_4;
9276 parse_func = lotus5_parse_hash;
9277 sort_by_digest = sort_by_digest_4_4;
9278 opti_type = OPTI_TYPE_EARLY_SKIP
9279 | OPTI_TYPE_NOT_ITERATED
9280 | OPTI_TYPE_NOT_SALTED
9281 | OPTI_TYPE_RAW_HASH;
9282 dgst_pos0 = 0;
9283 dgst_pos1 = 1;
9284 dgst_pos2 = 2;
9285 dgst_pos3 = 3;
9286 break;
9287
9288 case 8700: hash_type = HASH_TYPE_LOTUS6;
9289 salt_type = SALT_TYPE_EMBEDDED;
9290 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9291 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9292 kern_type = KERN_TYPE_LOTUS6;
9293 dgst_size = DGST_SIZE_4_4;
9294 parse_func = lotus6_parse_hash;
9295 sort_by_digest = sort_by_digest_4_4;
9296 opti_type = OPTI_TYPE_EARLY_SKIP
9297 | OPTI_TYPE_NOT_ITERATED
9298 | OPTI_TYPE_RAW_HASH;
9299 dgst_pos0 = 0;
9300 dgst_pos1 = 1;
9301 dgst_pos2 = 2;
9302 dgst_pos3 = 3;
9303 break;
9304
9305 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9306 salt_type = SALT_TYPE_EMBEDDED;
9307 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9308 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9309 kern_type = KERN_TYPE_ANDROIDFDE;
9310 dgst_size = DGST_SIZE_4_4;
9311 parse_func = androidfde_parse_hash;
9312 sort_by_digest = sort_by_digest_4_4;
9313 opti_type = OPTI_TYPE_ZERO_BYTE;
9314 dgst_pos0 = 0;
9315 dgst_pos1 = 1;
9316 dgst_pos2 = 2;
9317 dgst_pos3 = 3;
9318 break;
9319
9320 case 8900: hash_type = HASH_TYPE_SCRYPT;
9321 salt_type = SALT_TYPE_EMBEDDED;
9322 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9323 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9324 kern_type = KERN_TYPE_SCRYPT;
9325 dgst_size = DGST_SIZE_4_8;
9326 parse_func = scrypt_parse_hash;
9327 sort_by_digest = sort_by_digest_4_8;
9328 opti_type = OPTI_TYPE_ZERO_BYTE;
9329 dgst_pos0 = 0;
9330 dgst_pos1 = 1;
9331 dgst_pos2 = 2;
9332 dgst_pos3 = 3;
9333 break;
9334
9335 case 9000: hash_type = HASH_TYPE_SHA1;
9336 salt_type = SALT_TYPE_EMBEDDED;
9337 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9338 opts_type = OPTS_TYPE_PT_GENERATE_LE
9339 | OPTS_TYPE_ST_GENERATE_LE;
9340 kern_type = KERN_TYPE_PSAFE2;
9341 dgst_size = DGST_SIZE_4_5;
9342 parse_func = psafe2_parse_hash;
9343 sort_by_digest = sort_by_digest_4_5;
9344 opti_type = OPTI_TYPE_ZERO_BYTE;
9345 dgst_pos0 = 0;
9346 dgst_pos1 = 1;
9347 dgst_pos2 = 2;
9348 dgst_pos3 = 3;
9349 break;
9350
9351 case 9100: hash_type = HASH_TYPE_LOTUS8;
9352 salt_type = SALT_TYPE_EMBEDDED;
9353 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9354 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9355 kern_type = KERN_TYPE_LOTUS8;
9356 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9357 parse_func = lotus8_parse_hash;
9358 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9359 opti_type = OPTI_TYPE_ZERO_BYTE;
9360 dgst_pos0 = 0;
9361 dgst_pos1 = 1;
9362 dgst_pos2 = 2;
9363 dgst_pos3 = 3;
9364 break;
9365
9366 case 9200: hash_type = HASH_TYPE_SHA256;
9367 salt_type = SALT_TYPE_EMBEDDED;
9368 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9369 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9370 kern_type = KERN_TYPE_PBKDF2_SHA256;
9371 dgst_size = DGST_SIZE_4_32;
9372 parse_func = cisco8_parse_hash;
9373 sort_by_digest = sort_by_digest_4_32;
9374 opti_type = OPTI_TYPE_ZERO_BYTE;
9375 dgst_pos0 = 0;
9376 dgst_pos1 = 1;
9377 dgst_pos2 = 2;
9378 dgst_pos3 = 3;
9379 break;
9380
9381 case 9300: hash_type = HASH_TYPE_SCRYPT;
9382 salt_type = SALT_TYPE_EMBEDDED;
9383 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9384 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9385 kern_type = KERN_TYPE_SCRYPT;
9386 dgst_size = DGST_SIZE_4_8;
9387 parse_func = cisco9_parse_hash;
9388 sort_by_digest = sort_by_digest_4_8;
9389 opti_type = OPTI_TYPE_ZERO_BYTE;
9390 dgst_pos0 = 0;
9391 dgst_pos1 = 1;
9392 dgst_pos2 = 2;
9393 dgst_pos3 = 3;
9394 break;
9395
9396 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9397 salt_type = SALT_TYPE_EMBEDDED;
9398 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9399 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9400 kern_type = KERN_TYPE_OFFICE2007;
9401 dgst_size = DGST_SIZE_4_4;
9402 parse_func = office2007_parse_hash;
9403 sort_by_digest = sort_by_digest_4_4;
9404 opti_type = OPTI_TYPE_ZERO_BYTE;
9405 dgst_pos0 = 0;
9406 dgst_pos1 = 1;
9407 dgst_pos2 = 2;
9408 dgst_pos3 = 3;
9409 break;
9410
9411 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9412 salt_type = SALT_TYPE_EMBEDDED;
9413 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9414 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9415 kern_type = KERN_TYPE_OFFICE2010;
9416 dgst_size = DGST_SIZE_4_4;
9417 parse_func = office2010_parse_hash;
9418 sort_by_digest = sort_by_digest_4_4;
9419 opti_type = OPTI_TYPE_ZERO_BYTE;
9420 dgst_pos0 = 0;
9421 dgst_pos1 = 1;
9422 dgst_pos2 = 2;
9423 dgst_pos3 = 3;
9424 break;
9425
9426 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9427 salt_type = SALT_TYPE_EMBEDDED;
9428 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9429 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9430 kern_type = KERN_TYPE_OFFICE2013;
9431 dgst_size = DGST_SIZE_4_4;
9432 parse_func = office2013_parse_hash;
9433 sort_by_digest = sort_by_digest_4_4;
9434 opti_type = OPTI_TYPE_ZERO_BYTE;
9435 dgst_pos0 = 0;
9436 dgst_pos1 = 1;
9437 dgst_pos2 = 2;
9438 dgst_pos3 = 3;
9439 break;
9440
9441 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9442 salt_type = SALT_TYPE_EMBEDDED;
9443 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9444 opts_type = OPTS_TYPE_PT_GENERATE_LE
9445 | OPTS_TYPE_PT_ADD80
9446 | OPTS_TYPE_PT_UNICODE;
9447 kern_type = KERN_TYPE_OLDOFFICE01;
9448 dgst_size = DGST_SIZE_4_4;
9449 parse_func = oldoffice01_parse_hash;
9450 sort_by_digest = sort_by_digest_4_4;
9451 opti_type = OPTI_TYPE_ZERO_BYTE
9452 | OPTI_TYPE_PRECOMPUTE_INIT
9453 | OPTI_TYPE_NOT_ITERATED;
9454 dgst_pos0 = 0;
9455 dgst_pos1 = 1;
9456 dgst_pos2 = 2;
9457 dgst_pos3 = 3;
9458 break;
9459
9460 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9461 salt_type = SALT_TYPE_EMBEDDED;
9462 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9463 opts_type = OPTS_TYPE_PT_GENERATE_LE
9464 | OPTS_TYPE_PT_ADD80;
9465 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9466 dgst_size = DGST_SIZE_4_4;
9467 parse_func = oldoffice01cm1_parse_hash;
9468 sort_by_digest = sort_by_digest_4_4;
9469 opti_type = OPTI_TYPE_ZERO_BYTE
9470 | OPTI_TYPE_PRECOMPUTE_INIT
9471 | OPTI_TYPE_NOT_ITERATED;
9472 dgst_pos0 = 0;
9473 dgst_pos1 = 1;
9474 dgst_pos2 = 2;
9475 dgst_pos3 = 3;
9476 break;
9477
9478 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9479 salt_type = SALT_TYPE_EMBEDDED;
9480 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9481 opts_type = OPTS_TYPE_PT_GENERATE_LE
9482 | OPTS_TYPE_PT_ADD80
9483 | OPTS_TYPE_PT_UNICODE
9484 | OPTS_TYPE_PT_NEVERCRACK;
9485 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9486 dgst_size = DGST_SIZE_4_4;
9487 parse_func = oldoffice01cm2_parse_hash;
9488 sort_by_digest = sort_by_digest_4_4;
9489 opti_type = OPTI_TYPE_ZERO_BYTE
9490 | OPTI_TYPE_PRECOMPUTE_INIT
9491 | OPTI_TYPE_NOT_ITERATED;
9492 dgst_pos0 = 0;
9493 dgst_pos1 = 1;
9494 dgst_pos2 = 2;
9495 dgst_pos3 = 3;
9496 break;
9497
9498 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9499 salt_type = SALT_TYPE_EMBEDDED;
9500 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9501 opts_type = OPTS_TYPE_PT_GENERATE_BE
9502 | OPTS_TYPE_PT_ADD80
9503 | OPTS_TYPE_PT_UNICODE;
9504 kern_type = KERN_TYPE_OLDOFFICE34;
9505 dgst_size = DGST_SIZE_4_4;
9506 parse_func = oldoffice34_parse_hash;
9507 sort_by_digest = sort_by_digest_4_4;
9508 opti_type = OPTI_TYPE_ZERO_BYTE
9509 | OPTI_TYPE_PRECOMPUTE_INIT
9510 | OPTI_TYPE_NOT_ITERATED;
9511 dgst_pos0 = 0;
9512 dgst_pos1 = 1;
9513 dgst_pos2 = 2;
9514 dgst_pos3 = 3;
9515 break;
9516
9517 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9518 salt_type = SALT_TYPE_EMBEDDED;
9519 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9520 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9521 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9522 dgst_size = DGST_SIZE_4_4;
9523 parse_func = oldoffice34cm1_parse_hash;
9524 sort_by_digest = sort_by_digest_4_4;
9525 opti_type = OPTI_TYPE_ZERO_BYTE
9526 | OPTI_TYPE_PRECOMPUTE_INIT
9527 | OPTI_TYPE_NOT_ITERATED;
9528 dgst_pos0 = 0;
9529 dgst_pos1 = 1;
9530 dgst_pos2 = 2;
9531 dgst_pos3 = 3;
9532 break;
9533
9534 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9535 salt_type = SALT_TYPE_EMBEDDED;
9536 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9537 opts_type = OPTS_TYPE_PT_GENERATE_BE
9538 | OPTS_TYPE_PT_ADD80
9539 | OPTS_TYPE_PT_UNICODE
9540 | OPTS_TYPE_PT_NEVERCRACK;
9541 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9542 dgst_size = DGST_SIZE_4_4;
9543 parse_func = oldoffice34cm2_parse_hash;
9544 sort_by_digest = sort_by_digest_4_4;
9545 opti_type = OPTI_TYPE_ZERO_BYTE
9546 | OPTI_TYPE_PRECOMPUTE_INIT
9547 | OPTI_TYPE_NOT_ITERATED;
9548 dgst_pos0 = 0;
9549 dgst_pos1 = 1;
9550 dgst_pos2 = 2;
9551 dgst_pos3 = 3;
9552 break;
9553
9554 case 9900: hash_type = HASH_TYPE_MD5;
9555 salt_type = SALT_TYPE_NONE;
9556 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9557 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9558 kern_type = KERN_TYPE_RADMIN2;
9559 dgst_size = DGST_SIZE_4_4;
9560 parse_func = radmin2_parse_hash;
9561 sort_by_digest = sort_by_digest_4_4;
9562 opti_type = OPTI_TYPE_ZERO_BYTE
9563 | OPTI_TYPE_PRECOMPUTE_INIT
9564 | OPTI_TYPE_EARLY_SKIP
9565 | OPTI_TYPE_NOT_ITERATED
9566 | OPTI_TYPE_NOT_SALTED;
9567 dgst_pos0 = 0;
9568 dgst_pos1 = 3;
9569 dgst_pos2 = 2;
9570 dgst_pos3 = 1;
9571 break;
9572
9573 case 10000: hash_type = HASH_TYPE_SHA256;
9574 salt_type = SALT_TYPE_EMBEDDED;
9575 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9576 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9577 kern_type = KERN_TYPE_PBKDF2_SHA256;
9578 dgst_size = DGST_SIZE_4_32;
9579 parse_func = djangopbkdf2_parse_hash;
9580 sort_by_digest = sort_by_digest_4_32;
9581 opti_type = OPTI_TYPE_ZERO_BYTE;
9582 dgst_pos0 = 0;
9583 dgst_pos1 = 1;
9584 dgst_pos2 = 2;
9585 dgst_pos3 = 3;
9586 break;
9587
9588 case 10100: hash_type = HASH_TYPE_SIPHASH;
9589 salt_type = SALT_TYPE_EMBEDDED;
9590 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9591 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9592 kern_type = KERN_TYPE_SIPHASH;
9593 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9594 parse_func = siphash_parse_hash;
9595 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9596 opti_type = OPTI_TYPE_ZERO_BYTE
9597 | OPTI_TYPE_NOT_ITERATED
9598 | OPTI_TYPE_RAW_HASH;
9599 dgst_pos0 = 0;
9600 dgst_pos1 = 1;
9601 dgst_pos2 = 2;
9602 dgst_pos3 = 3;
9603 break;
9604
9605 case 10200: hash_type = HASH_TYPE_MD5;
9606 salt_type = SALT_TYPE_EMBEDDED;
9607 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9608 opts_type = OPTS_TYPE_PT_GENERATE_LE
9609 | OPTS_TYPE_ST_ADD80
9610 | OPTS_TYPE_ST_ADDBITS14;
9611 kern_type = KERN_TYPE_HMACMD5_PW;
9612 dgst_size = DGST_SIZE_4_4;
9613 parse_func = crammd5_parse_hash;
9614 sort_by_digest = sort_by_digest_4_4;
9615 opti_type = OPTI_TYPE_ZERO_BYTE
9616 | OPTI_TYPE_NOT_ITERATED;
9617 dgst_pos0 = 0;
9618 dgst_pos1 = 3;
9619 dgst_pos2 = 2;
9620 dgst_pos3 = 1;
9621 break;
9622
9623 case 10300: hash_type = HASH_TYPE_SHA1;
9624 salt_type = SALT_TYPE_EMBEDDED;
9625 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9626 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9627 kern_type = KERN_TYPE_SAPH_SHA1;
9628 dgst_size = DGST_SIZE_4_5;
9629 parse_func = saph_sha1_parse_hash;
9630 sort_by_digest = sort_by_digest_4_5;
9631 opti_type = OPTI_TYPE_ZERO_BYTE;
9632 dgst_pos0 = 0;
9633 dgst_pos1 = 1;
9634 dgst_pos2 = 2;
9635 dgst_pos3 = 3;
9636 break;
9637
9638 case 10400: hash_type = HASH_TYPE_PDFU16;
9639 salt_type = SALT_TYPE_EMBEDDED;
9640 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9641 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9642 kern_type = KERN_TYPE_PDF11;
9643 dgst_size = DGST_SIZE_4_4;
9644 parse_func = pdf11_parse_hash;
9645 sort_by_digest = sort_by_digest_4_4;
9646 opti_type = OPTI_TYPE_ZERO_BYTE
9647 | OPTI_TYPE_NOT_ITERATED;
9648 dgst_pos0 = 0;
9649 dgst_pos1 = 1;
9650 dgst_pos2 = 2;
9651 dgst_pos3 = 3;
9652 break;
9653
9654 case 10410: hash_type = HASH_TYPE_PDFU16;
9655 salt_type = SALT_TYPE_EMBEDDED;
9656 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9657 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9658 kern_type = KERN_TYPE_PDF11CM1;
9659 dgst_size = DGST_SIZE_4_4;
9660 parse_func = pdf11cm1_parse_hash;
9661 sort_by_digest = sort_by_digest_4_4;
9662 opti_type = OPTI_TYPE_ZERO_BYTE
9663 | OPTI_TYPE_NOT_ITERATED;
9664 dgst_pos0 = 0;
9665 dgst_pos1 = 1;
9666 dgst_pos2 = 2;
9667 dgst_pos3 = 3;
9668 break;
9669
9670 case 10420: hash_type = HASH_TYPE_PDFU16;
9671 salt_type = SALT_TYPE_EMBEDDED;
9672 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9673 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9674 kern_type = KERN_TYPE_PDF11CM2;
9675 dgst_size = DGST_SIZE_4_4;
9676 parse_func = pdf11cm2_parse_hash;
9677 sort_by_digest = sort_by_digest_4_4;
9678 opti_type = OPTI_TYPE_ZERO_BYTE
9679 | OPTI_TYPE_NOT_ITERATED;
9680 dgst_pos0 = 0;
9681 dgst_pos1 = 1;
9682 dgst_pos2 = 2;
9683 dgst_pos3 = 3;
9684 break;
9685
9686 case 10500: hash_type = HASH_TYPE_PDFU16;
9687 salt_type = SALT_TYPE_EMBEDDED;
9688 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9689 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9690 kern_type = KERN_TYPE_PDF14;
9691 dgst_size = DGST_SIZE_4_4;
9692 parse_func = pdf14_parse_hash;
9693 sort_by_digest = sort_by_digest_4_4;
9694 opti_type = OPTI_TYPE_ZERO_BYTE
9695 | OPTI_TYPE_NOT_ITERATED;
9696 dgst_pos0 = 0;
9697 dgst_pos1 = 1;
9698 dgst_pos2 = 2;
9699 dgst_pos3 = 3;
9700 break;
9701
9702 case 10600: hash_type = HASH_TYPE_SHA256;
9703 salt_type = SALT_TYPE_EMBEDDED;
9704 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9705 opts_type = OPTS_TYPE_PT_GENERATE_BE
9706 | OPTS_TYPE_ST_ADD80
9707 | OPTS_TYPE_ST_ADDBITS15
9708 | OPTS_TYPE_HASH_COPY;
9709 kern_type = KERN_TYPE_SHA256_PWSLT;
9710 dgst_size = DGST_SIZE_4_8;
9711 parse_func = pdf17l3_parse_hash;
9712 sort_by_digest = sort_by_digest_4_8;
9713 opti_type = OPTI_TYPE_ZERO_BYTE
9714 | OPTI_TYPE_PRECOMPUTE_INIT
9715 | OPTI_TYPE_PRECOMPUTE_MERKLE
9716 | OPTI_TYPE_EARLY_SKIP
9717 | OPTI_TYPE_NOT_ITERATED
9718 | OPTI_TYPE_APPENDED_SALT
9719 | OPTI_TYPE_RAW_HASH;
9720 dgst_pos0 = 3;
9721 dgst_pos1 = 7;
9722 dgst_pos2 = 2;
9723 dgst_pos3 = 6;
9724 break;
9725
9726 case 10700: hash_type = HASH_TYPE_PDFU32;
9727 salt_type = SALT_TYPE_EMBEDDED;
9728 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9729 opts_type = OPTS_TYPE_PT_GENERATE_LE
9730 | OPTS_TYPE_HASH_COPY;
9731 kern_type = KERN_TYPE_PDF17L8;
9732 dgst_size = DGST_SIZE_4_8;
9733 parse_func = pdf17l8_parse_hash;
9734 sort_by_digest = sort_by_digest_4_8;
9735 opti_type = OPTI_TYPE_ZERO_BYTE
9736 | OPTI_TYPE_NOT_ITERATED;
9737 dgst_pos0 = 0;
9738 dgst_pos1 = 1;
9739 dgst_pos2 = 2;
9740 dgst_pos3 = 3;
9741 break;
9742
9743 case 10800: hash_type = HASH_TYPE_SHA384;
9744 salt_type = SALT_TYPE_NONE;
9745 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9746 opts_type = OPTS_TYPE_PT_GENERATE_BE
9747 | OPTS_TYPE_PT_ADD80
9748 | OPTS_TYPE_PT_ADDBITS15;
9749 kern_type = KERN_TYPE_SHA384;
9750 dgst_size = DGST_SIZE_8_8;
9751 parse_func = sha384_parse_hash;
9752 sort_by_digest = sort_by_digest_8_8;
9753 opti_type = OPTI_TYPE_ZERO_BYTE
9754 | OPTI_TYPE_PRECOMPUTE_INIT
9755 | OPTI_TYPE_PRECOMPUTE_MERKLE
9756 | OPTI_TYPE_EARLY_SKIP
9757 | OPTI_TYPE_NOT_ITERATED
9758 | OPTI_TYPE_NOT_SALTED
9759 | OPTI_TYPE_USES_BITS_64
9760 | OPTI_TYPE_RAW_HASH;
9761 dgst_pos0 = 6;
9762 dgst_pos1 = 7;
9763 dgst_pos2 = 4;
9764 dgst_pos3 = 5;
9765 break;
9766
9767 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9768 salt_type = SALT_TYPE_EMBEDDED;
9769 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9770 opts_type = OPTS_TYPE_PT_GENERATE_LE
9771 | OPTS_TYPE_ST_BASE64
9772 | OPTS_TYPE_HASH_COPY;
9773 kern_type = KERN_TYPE_PBKDF2_SHA256;
9774 dgst_size = DGST_SIZE_4_32;
9775 parse_func = pbkdf2_sha256_parse_hash;
9776 sort_by_digest = sort_by_digest_4_32;
9777 opti_type = OPTI_TYPE_ZERO_BYTE;
9778 dgst_pos0 = 0;
9779 dgst_pos1 = 1;
9780 dgst_pos2 = 2;
9781 dgst_pos3 = 3;
9782 break;
9783
9784 case 11000: hash_type = HASH_TYPE_MD5;
9785 salt_type = SALT_TYPE_INTERN;
9786 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9787 opts_type = OPTS_TYPE_PT_GENERATE_LE
9788 | OPTS_TYPE_PT_ADD80;
9789 kern_type = KERN_TYPE_PRESTASHOP;
9790 dgst_size = DGST_SIZE_4_4;
9791 parse_func = prestashop_parse_hash;
9792 sort_by_digest = sort_by_digest_4_4;
9793 opti_type = OPTI_TYPE_ZERO_BYTE
9794 | OPTI_TYPE_PRECOMPUTE_INIT
9795 | OPTI_TYPE_NOT_ITERATED
9796 | OPTI_TYPE_PREPENDED_SALT;
9797 dgst_pos0 = 0;
9798 dgst_pos1 = 3;
9799 dgst_pos2 = 2;
9800 dgst_pos3 = 1;
9801 break;
9802
9803 case 11100: hash_type = HASH_TYPE_MD5;
9804 salt_type = SALT_TYPE_EMBEDDED;
9805 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9806 opts_type = OPTS_TYPE_PT_GENERATE_LE
9807 | OPTS_TYPE_ST_ADD80;
9808 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9809 dgst_size = DGST_SIZE_4_4;
9810 parse_func = postgresql_auth_parse_hash;
9811 sort_by_digest = sort_by_digest_4_4;
9812 opti_type = OPTI_TYPE_ZERO_BYTE
9813 | OPTI_TYPE_PRECOMPUTE_INIT
9814 | OPTI_TYPE_PRECOMPUTE_MERKLE
9815 | OPTI_TYPE_EARLY_SKIP;
9816 dgst_pos0 = 0;
9817 dgst_pos1 = 3;
9818 dgst_pos2 = 2;
9819 dgst_pos3 = 1;
9820 break;
9821
9822 case 11200: hash_type = HASH_TYPE_SHA1;
9823 salt_type = SALT_TYPE_EMBEDDED;
9824 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9825 opts_type = OPTS_TYPE_PT_GENERATE_BE
9826 | OPTS_TYPE_PT_ADD80
9827 | OPTS_TYPE_ST_HEX;
9828 kern_type = KERN_TYPE_MYSQL_AUTH;
9829 dgst_size = DGST_SIZE_4_5;
9830 parse_func = mysql_auth_parse_hash;
9831 sort_by_digest = sort_by_digest_4_5;
9832 opti_type = OPTI_TYPE_ZERO_BYTE
9833 | OPTI_TYPE_EARLY_SKIP;
9834 dgst_pos0 = 3;
9835 dgst_pos1 = 4;
9836 dgst_pos2 = 2;
9837 dgst_pos3 = 1;
9838 break;
9839
9840 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9841 salt_type = SALT_TYPE_EMBEDDED;
9842 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9843 opts_type = OPTS_TYPE_PT_GENERATE_LE
9844 | OPTS_TYPE_ST_HEX
9845 | OPTS_TYPE_ST_ADD80;
9846 kern_type = KERN_TYPE_BITCOIN_WALLET;
9847 dgst_size = DGST_SIZE_4_4;
9848 parse_func = bitcoin_wallet_parse_hash;
9849 sort_by_digest = sort_by_digest_4_4;
9850 opti_type = OPTI_TYPE_ZERO_BYTE;
9851 dgst_pos0 = 0;
9852 dgst_pos1 = 1;
9853 dgst_pos2 = 2;
9854 dgst_pos3 = 3;
9855 break;
9856
9857 case 11400: hash_type = HASH_TYPE_MD5;
9858 salt_type = SALT_TYPE_EMBEDDED;
9859 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9860 opts_type = OPTS_TYPE_PT_GENERATE_LE
9861 | OPTS_TYPE_PT_ADD80
9862 | OPTS_TYPE_HASH_COPY;
9863 kern_type = KERN_TYPE_SIP_AUTH;
9864 dgst_size = DGST_SIZE_4_4;
9865 parse_func = sip_auth_parse_hash;
9866 sort_by_digest = sort_by_digest_4_4;
9867 opti_type = OPTI_TYPE_ZERO_BYTE;
9868 dgst_pos0 = 0;
9869 dgst_pos1 = 3;
9870 dgst_pos2 = 2;
9871 dgst_pos3 = 1;
9872 break;
9873
9874 case 11500: hash_type = HASH_TYPE_CRC32;
9875 salt_type = SALT_TYPE_INTERN;
9876 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9877 opts_type = OPTS_TYPE_PT_GENERATE_LE
9878 | OPTS_TYPE_ST_GENERATE_LE
9879 | OPTS_TYPE_ST_HEX;
9880 kern_type = KERN_TYPE_CRC32;
9881 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9882 parse_func = crc32_parse_hash;
9883 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9884 opti_type = OPTI_TYPE_ZERO_BYTE;
9885 dgst_pos0 = 0;
9886 dgst_pos1 = 1;
9887 dgst_pos2 = 2;
9888 dgst_pos3 = 3;
9889 break;
9890
9891 case 11600: hash_type = HASH_TYPE_AES;
9892 salt_type = SALT_TYPE_EMBEDDED;
9893 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9894 opts_type = OPTS_TYPE_PT_GENERATE_LE
9895 | OPTS_TYPE_PT_NEVERCRACK;
9896 kern_type = KERN_TYPE_SEVEN_ZIP;
9897 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9898 parse_func = seven_zip_parse_hash;
9899 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9900 opti_type = OPTI_TYPE_ZERO_BYTE;
9901 dgst_pos0 = 0;
9902 dgst_pos1 = 1;
9903 dgst_pos2 = 2;
9904 dgst_pos3 = 3;
9905 break;
9906
9907 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9908 salt_type = SALT_TYPE_NONE;
9909 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9910 opts_type = OPTS_TYPE_PT_GENERATE_LE
9911 | OPTS_TYPE_PT_ADD01;
9912 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9913 dgst_size = DGST_SIZE_4_8;
9914 parse_func = gost2012sbog_256_parse_hash;
9915 sort_by_digest = sort_by_digest_4_8;
9916 opti_type = OPTI_TYPE_ZERO_BYTE;
9917 dgst_pos0 = 0;
9918 dgst_pos1 = 1;
9919 dgst_pos2 = 2;
9920 dgst_pos3 = 3;
9921 break;
9922
9923 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
9924 salt_type = SALT_TYPE_NONE;
9925 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9926 opts_type = OPTS_TYPE_PT_GENERATE_LE
9927 | OPTS_TYPE_PT_ADD01;
9928 kern_type = KERN_TYPE_GOST_2012SBOG_512;
9929 dgst_size = DGST_SIZE_4_16;
9930 parse_func = gost2012sbog_512_parse_hash;
9931 sort_by_digest = sort_by_digest_4_16;
9932 opti_type = OPTI_TYPE_ZERO_BYTE;
9933 dgst_pos0 = 0;
9934 dgst_pos1 = 1;
9935 dgst_pos2 = 2;
9936 dgst_pos3 = 3;
9937 break;
9938
9939 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
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_BASE64
9944 | OPTS_TYPE_HASH_COPY;
9945 kern_type = KERN_TYPE_PBKDF2_MD5;
9946 dgst_size = DGST_SIZE_4_32;
9947 parse_func = pbkdf2_md5_parse_hash;
9948 sort_by_digest = sort_by_digest_4_32;
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 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
9957 salt_type = SALT_TYPE_EMBEDDED;
9958 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9959 opts_type = OPTS_TYPE_PT_GENERATE_LE
9960 | OPTS_TYPE_ST_BASE64
9961 | OPTS_TYPE_HASH_COPY;
9962 kern_type = KERN_TYPE_PBKDF2_SHA1;
9963 dgst_size = DGST_SIZE_4_32;
9964 parse_func = pbkdf2_sha1_parse_hash;
9965 sort_by_digest = sort_by_digest_4_32;
9966 opti_type = OPTI_TYPE_ZERO_BYTE;
9967 dgst_pos0 = 0;
9968 dgst_pos1 = 1;
9969 dgst_pos2 = 2;
9970 dgst_pos3 = 3;
9971 break;
9972
9973 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
9974 salt_type = SALT_TYPE_EMBEDDED;
9975 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9976 opts_type = OPTS_TYPE_PT_GENERATE_LE
9977 | OPTS_TYPE_ST_BASE64
9978 | OPTS_TYPE_HASH_COPY;
9979 kern_type = KERN_TYPE_PBKDF2_SHA512;
9980 dgst_size = DGST_SIZE_8_16;
9981 parse_func = pbkdf2_sha512_parse_hash;
9982 sort_by_digest = sort_by_digest_8_16;
9983 opti_type = OPTI_TYPE_ZERO_BYTE
9984 | OPTI_TYPE_USES_BITS_64;
9985 dgst_pos0 = 0;
9986 dgst_pos1 = 1;
9987 dgst_pos2 = 2;
9988 dgst_pos3 = 3;
9989 break;
9990
9991 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
9992 salt_type = SALT_TYPE_EMBEDDED;
9993 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9994 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9995 kern_type = KERN_TYPE_ECRYPTFS;
9996 dgst_size = DGST_SIZE_8_8;
9997 parse_func = ecryptfs_parse_hash;
9998 sort_by_digest = sort_by_digest_8_8;
9999 opti_type = OPTI_TYPE_ZERO_BYTE
10000 | OPTI_TYPE_USES_BITS_64;
10001 dgst_pos0 = 0;
10002 dgst_pos1 = 1;
10003 dgst_pos2 = 2;
10004 dgst_pos3 = 3;
10005 break;
10006
10007 case 12300: hash_type = HASH_TYPE_ORACLET;
10008 salt_type = SALT_TYPE_EMBEDDED;
10009 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10010 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10011 kern_type = KERN_TYPE_ORACLET;
10012 dgst_size = DGST_SIZE_8_16;
10013 parse_func = oraclet_parse_hash;
10014 sort_by_digest = sort_by_digest_8_16;
10015 opti_type = OPTI_TYPE_ZERO_BYTE
10016 | OPTI_TYPE_USES_BITS_64;
10017 dgst_pos0 = 0;
10018 dgst_pos1 = 1;
10019 dgst_pos2 = 2;
10020 dgst_pos3 = 3;
10021 break;
10022
10023 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10024 salt_type = SALT_TYPE_EMBEDDED;
10025 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10026 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10027 kern_type = KERN_TYPE_BSDICRYPT;
10028 dgst_size = DGST_SIZE_4_4;
10029 parse_func = bsdicrypt_parse_hash;
10030 sort_by_digest = sort_by_digest_4_4;
10031 opti_type = OPTI_TYPE_ZERO_BYTE
10032 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10033 dgst_pos0 = 0;
10034 dgst_pos1 = 1;
10035 dgst_pos2 = 2;
10036 dgst_pos3 = 3;
10037 break;
10038
10039 case 12500: hash_type = HASH_TYPE_RAR3HP;
10040 salt_type = SALT_TYPE_EMBEDDED;
10041 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10042 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10043 kern_type = KERN_TYPE_RAR3;
10044 dgst_size = DGST_SIZE_4_4;
10045 parse_func = rar3hp_parse_hash;
10046 sort_by_digest = sort_by_digest_4_4;
10047 opti_type = OPTI_TYPE_ZERO_BYTE;
10048 dgst_pos0 = 0;
10049 dgst_pos1 = 1;
10050 dgst_pos2 = 2;
10051 dgst_pos3 = 3;
10052 break;
10053
10054 case 12600: hash_type = HASH_TYPE_SHA256;
10055 salt_type = SALT_TYPE_INTERN;
10056 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10057 opts_type = OPTS_TYPE_PT_GENERATE_BE
10058 | OPTS_TYPE_PT_ADD80;
10059 kern_type = KERN_TYPE_CF10;
10060 dgst_size = DGST_SIZE_4_8;
10061 parse_func = cf10_parse_hash;
10062 sort_by_digest = sort_by_digest_4_8;
10063 opti_type = OPTI_TYPE_ZERO_BYTE
10064 | OPTI_TYPE_PRECOMPUTE_INIT
10065 | OPTI_TYPE_EARLY_SKIP
10066 | OPTI_TYPE_NOT_ITERATED;
10067 dgst_pos0 = 3;
10068 dgst_pos1 = 7;
10069 dgst_pos2 = 2;
10070 dgst_pos3 = 6;
10071 break;
10072
10073 case 12700: hash_type = HASH_TYPE_AES;
10074 salt_type = SALT_TYPE_EMBEDDED;
10075 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10076 opts_type = OPTS_TYPE_PT_GENERATE_LE
10077 | OPTS_TYPE_HASH_COPY;
10078 kern_type = KERN_TYPE_MYWALLET;
10079 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10080 parse_func = mywallet_parse_hash;
10081 sort_by_digest = sort_by_digest_4_5;
10082 opti_type = OPTI_TYPE_ZERO_BYTE;
10083 dgst_pos0 = 0;
10084 dgst_pos1 = 1;
10085 dgst_pos2 = 2;
10086 dgst_pos3 = 3;
10087 break;
10088
10089 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10090 salt_type = SALT_TYPE_EMBEDDED;
10091 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10092 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10093 kern_type = KERN_TYPE_MS_DRSR;
10094 dgst_size = DGST_SIZE_4_8;
10095 parse_func = ms_drsr_parse_hash;
10096 sort_by_digest = sort_by_digest_4_8;
10097 opti_type = OPTI_TYPE_ZERO_BYTE;
10098 dgst_pos0 = 0;
10099 dgst_pos1 = 1;
10100 dgst_pos2 = 2;
10101 dgst_pos3 = 3;
10102 break;
10103
10104 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10105 salt_type = SALT_TYPE_EMBEDDED;
10106 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10107 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10108 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10109 dgst_size = DGST_SIZE_4_8;
10110 parse_func = androidfde_samsung_parse_hash;
10111 sort_by_digest = sort_by_digest_4_8;
10112 opti_type = OPTI_TYPE_ZERO_BYTE;
10113 dgst_pos0 = 0;
10114 dgst_pos1 = 1;
10115 dgst_pos2 = 2;
10116 dgst_pos3 = 3;
10117 break;
10118
10119 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10120 salt_type = SALT_TYPE_EMBEDDED;
10121 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10122 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10123 kern_type = KERN_TYPE_RAR5;
10124 dgst_size = DGST_SIZE_4_4;
10125 parse_func = rar5_parse_hash;
10126 sort_by_digest = sort_by_digest_4_4;
10127 opti_type = OPTI_TYPE_ZERO_BYTE;
10128 dgst_pos0 = 0;
10129 dgst_pos1 = 1;
10130 dgst_pos2 = 2;
10131 dgst_pos3 = 3;
10132 break;
10133
10134 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10135 salt_type = SALT_TYPE_EMBEDDED;
10136 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10137 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10138 kern_type = KERN_TYPE_KRB5TGS;
10139 dgst_size = DGST_SIZE_4_4;
10140 parse_func = krb5tgs_parse_hash;
10141 sort_by_digest = sort_by_digest_4_4;
10142 opti_type = OPTI_TYPE_ZERO_BYTE
10143 | OPTI_TYPE_NOT_ITERATED;
10144 dgst_pos0 = 0;
10145 dgst_pos1 = 1;
10146 dgst_pos2 = 2;
10147 dgst_pos3 = 3;
10148 break;
10149
10150 case 13200: hash_type = HASH_TYPE_AES;
10151 salt_type = SALT_TYPE_EMBEDDED;
10152 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10153 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10154 kern_type = KERN_TYPE_AXCRYPT;
10155 dgst_size = DGST_SIZE_4_4;
10156 parse_func = axcrypt_parse_hash;
10157 sort_by_digest = sort_by_digest_4_4;
10158 opti_type = OPTI_TYPE_ZERO_BYTE;
10159 dgst_pos0 = 0;
10160 dgst_pos1 = 1;
10161 dgst_pos2 = 2;
10162 dgst_pos3 = 3;
10163 break;
10164
10165 case 13300: hash_type = HASH_TYPE_SHA1;
10166 salt_type = SALT_TYPE_NONE;
10167 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10168 opts_type = OPTS_TYPE_PT_GENERATE_BE
10169 | OPTS_TYPE_PT_ADD80
10170 | OPTS_TYPE_PT_ADDBITS15;
10171 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10172 dgst_size = DGST_SIZE_4_5;
10173 parse_func = sha1axcrypt_parse_hash;
10174 sort_by_digest = sort_by_digest_4_5;
10175 opti_type = OPTI_TYPE_ZERO_BYTE
10176 | OPTI_TYPE_PRECOMPUTE_INIT
10177 | OPTI_TYPE_EARLY_SKIP
10178 | OPTI_TYPE_NOT_ITERATED
10179 | OPTI_TYPE_NOT_SALTED;
10180 dgst_pos0 = 0;
10181 dgst_pos1 = 4;
10182 dgst_pos2 = 3;
10183 dgst_pos3 = 2;
10184 break;
10185
10186 case 13400: hash_type = HASH_TYPE_AES;
10187 salt_type = SALT_TYPE_EMBEDDED;
10188 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10189 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10190 kern_type = KERN_TYPE_KEEPASS;
10191 dgst_size = DGST_SIZE_4_4;
10192 parse_func = keepass_parse_hash;
10193 sort_by_digest = sort_by_digest_4_4;
10194 opti_type = OPTI_TYPE_ZERO_BYTE;
10195 dgst_pos0 = 0;
10196 dgst_pos1 = 1;
10197 dgst_pos2 = 2;
10198 dgst_pos3 = 3;
10199 break;
10200
10201 case 13500: hash_type = HASH_TYPE_SHA1;
10202 salt_type = SALT_TYPE_EMBEDDED;
10203 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10204 opts_type = OPTS_TYPE_PT_GENERATE_BE
10205 | OPTS_TYPE_PT_UNICODE
10206 | OPTS_TYPE_PT_ADD80;
10207 kern_type = KERN_TYPE_PSTOKEN;
10208 dgst_size = DGST_SIZE_4_5;
10209 parse_func = pstoken_parse_hash;
10210 sort_by_digest = sort_by_digest_4_5;
10211 opti_type = OPTI_TYPE_ZERO_BYTE
10212 | OPTI_TYPE_PRECOMPUTE_INIT
10213 | OPTI_TYPE_EARLY_SKIP
10214 | OPTI_TYPE_NOT_ITERATED
10215 | OPTI_TYPE_PREPENDED_SALT
10216 | OPTI_TYPE_RAW_HASH;
10217 dgst_pos0 = 3;
10218 dgst_pos1 = 4;
10219 dgst_pos2 = 2;
10220 dgst_pos3 = 1;
10221 break;
10222
10223 default: usage_mini_print (PROGNAME); return (-1);
10224 }
10225
10226 /**
10227 * parser
10228 */
10229
10230 data.parse_func = parse_func;
10231
10232 /**
10233 * misc stuff
10234 */
10235
10236 if (hex_salt)
10237 {
10238 if (salt_type == SALT_TYPE_INTERN)
10239 {
10240 opts_type |= OPTS_TYPE_ST_HEX;
10241 }
10242 else
10243 {
10244 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10245
10246 return (-1);
10247 }
10248 }
10249
10250 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10251 | (salt_type == SALT_TYPE_EXTERN)
10252 | (salt_type == SALT_TYPE_EMBEDDED)
10253 | (salt_type == SALT_TYPE_VIRTUAL));
10254
10255 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10256
10257 data.hash_type = hash_type;
10258 data.attack_mode = attack_mode;
10259 data.attack_kern = attack_kern;
10260 data.attack_exec = attack_exec;
10261 data.kern_type = kern_type;
10262 data.opts_type = opts_type;
10263 data.dgst_size = dgst_size;
10264 data.salt_type = salt_type;
10265 data.isSalted = isSalted;
10266 data.sort_by_digest = sort_by_digest;
10267 data.dgst_pos0 = dgst_pos0;
10268 data.dgst_pos1 = dgst_pos1;
10269 data.dgst_pos2 = dgst_pos2;
10270 data.dgst_pos3 = dgst_pos3;
10271
10272 esalt_size = 0;
10273
10274 switch (hash_mode)
10275 {
10276 case 2500: esalt_size = sizeof (wpa_t); break;
10277 case 5300: esalt_size = sizeof (ikepsk_t); break;
10278 case 5400: esalt_size = sizeof (ikepsk_t); break;
10279 case 5500: esalt_size = sizeof (netntlm_t); break;
10280 case 5600: esalt_size = sizeof (netntlm_t); break;
10281 case 6211: esalt_size = sizeof (tc_t); break;
10282 case 6212: esalt_size = sizeof (tc_t); break;
10283 case 6213: esalt_size = sizeof (tc_t); break;
10284 case 6221: esalt_size = sizeof (tc_t); break;
10285 case 6222: esalt_size = sizeof (tc_t); break;
10286 case 6223: esalt_size = sizeof (tc_t); break;
10287 case 6231: esalt_size = sizeof (tc_t); break;
10288 case 6232: esalt_size = sizeof (tc_t); break;
10289 case 6233: esalt_size = sizeof (tc_t); break;
10290 case 6241: esalt_size = sizeof (tc_t); break;
10291 case 6242: esalt_size = sizeof (tc_t); break;
10292 case 6243: esalt_size = sizeof (tc_t); break;
10293 case 6600: esalt_size = sizeof (agilekey_t); break;
10294 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10295 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10296 case 7300: esalt_size = sizeof (rakp_t); break;
10297 case 7500: esalt_size = sizeof (krb5pa_t); break;
10298 case 8200: esalt_size = sizeof (cloudkey_t); break;
10299 case 8800: esalt_size = sizeof (androidfde_t); break;
10300 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10301 case 9400: esalt_size = sizeof (office2007_t); break;
10302 case 9500: esalt_size = sizeof (office2010_t); break;
10303 case 9600: esalt_size = sizeof (office2013_t); break;
10304 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10305 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10306 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10307 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10308 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10309 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10310 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10311 case 10200: esalt_size = sizeof (cram_md5_t); break;
10312 case 10400: esalt_size = sizeof (pdf_t); break;
10313 case 10410: esalt_size = sizeof (pdf_t); break;
10314 case 10420: esalt_size = sizeof (pdf_t); break;
10315 case 10500: esalt_size = sizeof (pdf_t); break;
10316 case 10600: esalt_size = sizeof (pdf_t); break;
10317 case 10700: esalt_size = sizeof (pdf_t); break;
10318 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10319 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10320 case 11400: esalt_size = sizeof (sip_t); break;
10321 case 11600: esalt_size = sizeof (seven_zip_t); break;
10322 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10323 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10324 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10325 case 13000: esalt_size = sizeof (rar5_t); break;
10326 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10327 case 13400: esalt_size = sizeof (keepass_t); break;
10328 case 13500: esalt_size = sizeof (pstoken_t); break;
10329 }
10330
10331 data.esalt_size = esalt_size;
10332
10333 /**
10334 * choose dictionary parser
10335 */
10336
10337 if (hash_type == HASH_TYPE_LM)
10338 {
10339 get_next_word_func = get_next_word_lm;
10340 }
10341 else if (opts_type & OPTS_TYPE_PT_UPPER)
10342 {
10343 get_next_word_func = get_next_word_uc;
10344 }
10345 else
10346 {
10347 get_next_word_func = get_next_word_std;
10348 }
10349
10350 /**
10351 * dictstat
10352 */
10353
10354 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10355
10356 #ifdef _POSIX
10357 size_t dictstat_nmemb = 0;
10358 #endif
10359
10360 #ifdef _WIN
10361 uint dictstat_nmemb = 0;
10362 #endif
10363
10364 char dictstat[256] = { 0 };
10365
10366 FILE *dictstat_fp = NULL;
10367
10368 if (keyspace == 0)
10369 {
10370 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
10371
10372 dictstat_fp = fopen (dictstat, "rb");
10373
10374 if (dictstat_fp)
10375 {
10376 #ifdef _POSIX
10377 struct stat tmpstat;
10378
10379 fstat (fileno (dictstat_fp), &tmpstat);
10380 #endif
10381
10382 #ifdef _WIN
10383 struct stat64 tmpstat;
10384
10385 _fstat64 (fileno (dictstat_fp), &tmpstat);
10386 #endif
10387
10388 if (tmpstat.st_mtime < COMPTIME)
10389 {
10390 /* with v0.15 the format changed so we have to ensure user is using a good version
10391 since there is no version-header in the dictstat file */
10392
10393 fclose (dictstat_fp);
10394
10395 unlink (dictstat);
10396 }
10397 else
10398 {
10399 while (!feof (dictstat_fp))
10400 {
10401 dictstat_t d;
10402
10403 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10404
10405 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10406
10407 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10408 {
10409 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10410
10411 return -1;
10412 }
10413 }
10414
10415 fclose (dictstat_fp);
10416 }
10417 }
10418 }
10419
10420 /**
10421 * potfile
10422 */
10423
10424 char potfile[256] = { 0 };
10425
10426 if (potfile_path == NULL)
10427 {
10428 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
10429 }
10430 else
10431 {
10432 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
10433 }
10434
10435 data.pot_fp = NULL;
10436
10437 FILE *out_fp = NULL;
10438 FILE *pot_fp = NULL;
10439
10440 if (show == 1 || left == 1)
10441 {
10442 pot_fp = fopen (potfile, "rb");
10443
10444 if (pot_fp == NULL)
10445 {
10446 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10447
10448 return (-1);
10449 }
10450
10451 if (outfile != NULL)
10452 {
10453 if ((out_fp = fopen (outfile, "ab")) == NULL)
10454 {
10455 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10456
10457 fclose (pot_fp);
10458
10459 return (-1);
10460 }
10461 }
10462 else
10463 {
10464 out_fp = stdout;
10465 }
10466 }
10467 else
10468 {
10469 if (potfile_disable == 0)
10470 {
10471 pot_fp = fopen (potfile, "ab");
10472
10473 if (pot_fp == NULL)
10474 {
10475 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10476
10477 return (-1);
10478 }
10479
10480 data.pot_fp = pot_fp;
10481 }
10482 }
10483
10484 pot_t *pot = NULL;
10485
10486 uint pot_cnt = 0;
10487 uint pot_avail = 0;
10488
10489 if (show == 1 || left == 1)
10490 {
10491 SUPPRESS_OUTPUT = 1;
10492
10493 pot_avail = count_lines (pot_fp);
10494
10495 rewind (pot_fp);
10496
10497 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10498
10499 uint pot_hashes_avail = 0;
10500
10501 uint line_num = 0;
10502
10503 char *line_buf = (char *) mymalloc (HCBUFSIZ);
10504
10505 while (!feof (pot_fp))
10506 {
10507 line_num++;
10508
10509 int line_len = fgetl (pot_fp, line_buf);
10510
10511 if (line_len == 0) continue;
10512
10513 char *plain_buf = line_buf + line_len;
10514
10515 pot_t *pot_ptr = &pot[pot_cnt];
10516
10517 hash_t *hashes_buf = &pot_ptr->hash;
10518
10519 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10520 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10521
10522 if (pot_cnt == pot_hashes_avail)
10523 {
10524 uint pos = 0;
10525
10526 for (pos = 0; pos < INCR_POT; pos++)
10527 {
10528 if ((pot_cnt + pos) >= pot_avail) break;
10529
10530 pot_t *tmp_pot = &pot[pot_cnt + pos];
10531
10532 hash_t *tmp_hash = &tmp_pot->hash;
10533
10534 tmp_hash->digest = mymalloc (dgst_size);
10535
10536 if (isSalted)
10537 {
10538 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10539 }
10540
10541 if (esalt_size)
10542 {
10543 tmp_hash->esalt = mymalloc (esalt_size);
10544 }
10545
10546 pot_hashes_avail++;
10547 }
10548 }
10549
10550 int plain_len = 0;
10551
10552 int parser_status;
10553
10554 int iter = MAX_CUT_TRIES;
10555
10556 do
10557 {
10558 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10559 {
10560 if (line_buf[i] == ':')
10561 {
10562 line_len--;
10563
10564 break;
10565 }
10566 }
10567
10568 if (data.hash_mode != 2500)
10569 {
10570 parser_status = parse_func (line_buf, line_len, hashes_buf);
10571 }
10572 else
10573 {
10574 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10575
10576 if (line_len > max_salt_size)
10577 {
10578 parser_status = PARSER_GLOBAL_LENGTH;
10579 }
10580 else
10581 {
10582 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10583
10584 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10585
10586 hashes_buf->salt->salt_len = line_len;
10587
10588 parser_status = PARSER_OK;
10589 }
10590 }
10591
10592 // if NOT parsed without error, we add the ":" to the plain
10593
10594 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10595 {
10596 plain_len++;
10597 plain_buf--;
10598 }
10599
10600 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10601
10602 if (parser_status < PARSER_GLOBAL_ZERO)
10603 {
10604 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10605
10606 continue;
10607 }
10608
10609 if (plain_len >= 255) continue;
10610
10611 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10612
10613 pot_ptr->plain_len = plain_len;
10614
10615 pot_cnt++;
10616 }
10617
10618 myfree (line_buf);
10619
10620 fclose (pot_fp);
10621
10622 SUPPRESS_OUTPUT = 0;
10623
10624 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10625 }
10626
10627 /**
10628 * word len
10629 */
10630
10631 uint pw_min = PW_MIN;
10632 uint pw_max = PW_MAX;
10633
10634 switch (hash_mode)
10635 {
10636 case 125: if (pw_max > 32) pw_max = 32;
10637 break;
10638 case 400: if (pw_max > 40) pw_max = 40;
10639 break;
10640 case 500: if (pw_max > 16) pw_max = 16;
10641 break;
10642 case 1500: if (pw_max > 8) pw_max = 8;
10643 break;
10644 case 1600: if (pw_max > 16) pw_max = 16;
10645 break;
10646 case 1800: if (pw_max > 16) pw_max = 16;
10647 break;
10648 case 2100: if (pw_max > 16) pw_max = 16;
10649 break;
10650 case 2500: if (pw_min < 8) pw_min = 8;
10651 break;
10652 case 3000: if (pw_max > 7) pw_max = 7;
10653 break;
10654 case 5200: if (pw_max > 24) pw_max = 24;
10655 break;
10656 case 5800: if (pw_max > 16) pw_max = 16;
10657 break;
10658 case 6300: if (pw_max > 16) pw_max = 16;
10659 break;
10660 case 7400: if (pw_max > 16) pw_max = 16;
10661 break;
10662 case 7900: if (pw_max > 48) pw_max = 48;
10663 break;
10664 case 8500: if (pw_max > 8) pw_max = 8;
10665 break;
10666 case 8600: if (pw_max > 16) pw_max = 16;
10667 break;
10668 case 9710: pw_min = 5;
10669 pw_max = 5;
10670 break;
10671 case 9810: pw_min = 5;
10672 pw_max = 5;
10673 break;
10674 case 10410: pw_min = 5;
10675 pw_max = 5;
10676 break;
10677 case 10300: if (pw_max < 3) pw_min = 3;
10678 if (pw_max > 40) pw_max = 40;
10679 break;
10680 case 10500: if (pw_max < 3) pw_min = 3;
10681 if (pw_max > 40) pw_max = 40;
10682 break;
10683 case 10700: if (pw_max > 16) pw_max = 16;
10684 break;
10685 case 11300: if (pw_max > 40) pw_max = 40;
10686 break;
10687 case 11600: if (pw_max > 32) pw_max = 32;
10688 break;
10689 case 12500: if (pw_max > 20) pw_max = 20;
10690 break;
10691 case 12800: if (pw_max > 24) pw_max = 24;
10692 break;
10693 }
10694
10695 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10696 {
10697 switch (attack_kern)
10698 {
10699 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10700 break;
10701 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10702 break;
10703 }
10704 }
10705
10706 /**
10707 * charsets : keep them together for more easy maintainnce
10708 */
10709
10710 cs_t mp_sys[6] = { { { 0 }, 0 } };
10711 cs_t mp_usr[4] = { { { 0 }, 0 } };
10712
10713 mp_setup_sys (mp_sys);
10714
10715 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10716 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10717 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10718 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10719
10720 /**
10721 * load hashes, part I: find input mode, count hashes
10722 */
10723
10724 uint hashlist_mode = 0;
10725 uint hashlist_format = HLFMT_HASHCAT;
10726
10727 uint hashes_avail = 0;
10728
10729 if (benchmark == 0)
10730 {
10731 struct stat f;
10732
10733 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10734
10735 if ((hash_mode == 2500) ||
10736 (hash_mode == 5200) ||
10737 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10738 (hash_mode == 9000))
10739 {
10740 hashlist_mode = HL_MODE_ARG;
10741
10742 char *hashfile = myargv[optind];
10743
10744 data.hashfile = hashfile;
10745
10746 logfile_top_var_string ("target", hashfile);
10747 }
10748
10749 if (hashlist_mode == HL_MODE_ARG)
10750 {
10751 if (hash_mode == 2500)
10752 {
10753 struct stat st;
10754
10755 if (stat (data.hashfile, &st) == -1)
10756 {
10757 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10758
10759 return (-1);
10760 }
10761
10762 hashes_avail = st.st_size / sizeof (hccap_t);
10763 }
10764 else
10765 {
10766 hashes_avail = 1;
10767 }
10768 }
10769 else if (hashlist_mode == HL_MODE_FILE)
10770 {
10771 char *hashfile = myargv[optind];
10772
10773 data.hashfile = hashfile;
10774
10775 logfile_top_var_string ("target", hashfile);
10776
10777 FILE *fp = NULL;
10778
10779 if ((fp = fopen (hashfile, "rb")) == NULL)
10780 {
10781 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10782
10783 return (-1);
10784 }
10785
10786 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10787
10788 hashes_avail = count_lines (fp);
10789
10790 rewind (fp);
10791
10792 if (hashes_avail == 0)
10793 {
10794 log_error ("ERROR: hashfile is empty or corrupt");
10795
10796 fclose (fp);
10797
10798 return (-1);
10799 }
10800
10801 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10802
10803 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10804 {
10805 log_error ("ERROR: remove not supported in native hashfile-format mode");
10806
10807 fclose (fp);
10808
10809 return (-1);
10810 }
10811
10812 fclose (fp);
10813 }
10814 }
10815 else
10816 {
10817 hashlist_mode = HL_MODE_ARG;
10818
10819 hashes_avail = 1;
10820 }
10821
10822 if (hash_mode == 3000) hashes_avail *= 2;
10823
10824 data.hashlist_mode = hashlist_mode;
10825 data.hashlist_format = hashlist_format;
10826
10827 logfile_top_uint (hashlist_mode);
10828 logfile_top_uint (hashlist_format);
10829
10830 /**
10831 * load hashes, part II: allocate required memory, set pointers
10832 */
10833
10834 hash_t *hashes_buf = NULL;
10835 void *digests_buf = NULL;
10836 salt_t *salts_buf = NULL;
10837 void *esalts_buf = NULL;
10838
10839 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10840
10841 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10842
10843 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10844 {
10845 u32 hash_pos;
10846
10847 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10848 {
10849 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10850
10851 hashes_buf[hash_pos].hash_info = hash_info;
10852
10853 if (username && (remove || show || left))
10854 {
10855 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10856 }
10857
10858 if (benchmark)
10859 {
10860 hash_info->orighash = (char *) mymalloc (256);
10861 }
10862 }
10863 }
10864
10865 if (isSalted)
10866 {
10867 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10868
10869 if (esalt_size)
10870 {
10871 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10872 }
10873 }
10874 else
10875 {
10876 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10877 }
10878
10879 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10880 {
10881 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10882
10883 if (isSalted)
10884 {
10885 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10886
10887 if (esalt_size)
10888 {
10889 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10890 }
10891 }
10892 else
10893 {
10894 hashes_buf[hash_pos].salt = &salts_buf[0];
10895 }
10896 }
10897
10898 /**
10899 * load hashes, part III: parse hashes or generate them if benchmark
10900 */
10901
10902 uint hashes_cnt = 0;
10903
10904 if (benchmark == 0)
10905 {
10906 if (keyspace == 1)
10907 {
10908 // useless to read hash file for keyspace, cheat a little bit w/ optind
10909 }
10910 else if (hashes_avail == 0)
10911 {
10912 }
10913 else if (hashlist_mode == HL_MODE_ARG)
10914 {
10915 char *input_buf = myargv[optind];
10916
10917 uint input_len = strlen (input_buf);
10918
10919 logfile_top_var_string ("target", input_buf);
10920
10921 char *hash_buf = NULL;
10922 int hash_len = 0;
10923
10924 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10925
10926 bool hash_fmt_error = 0;
10927
10928 if (hash_len < 1) hash_fmt_error = 1;
10929 if (hash_buf == NULL) hash_fmt_error = 1;
10930
10931 if (hash_fmt_error)
10932 {
10933 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
10934 }
10935 else
10936 {
10937 if (opts_type & OPTS_TYPE_HASH_COPY)
10938 {
10939 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10940
10941 hash_info_tmp->orighash = mystrdup (hash_buf);
10942 }
10943
10944 if (isSalted)
10945 {
10946 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
10947 }
10948
10949 int parser_status = PARSER_OK;
10950
10951 if (hash_mode == 2500)
10952 {
10953 if (hash_len == 0)
10954 {
10955 log_error ("ERROR: hccap file not specified");
10956
10957 return (-1);
10958 }
10959
10960 hashlist_mode = HL_MODE_FILE;
10961
10962 data.hashlist_mode = hashlist_mode;
10963
10964 FILE *fp = fopen (hash_buf, "rb");
10965
10966 if (fp == NULL)
10967 {
10968 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
10969
10970 return (-1);
10971 }
10972
10973 if (hashes_avail < 1)
10974 {
10975 log_error ("ERROR: hccap file is empty or corrupt");
10976
10977 fclose (fp);
10978
10979 return (-1);
10980 }
10981
10982 uint hccap_size = sizeof (hccap_t);
10983
10984 char *in = (char *) mymalloc (hccap_size);
10985
10986 while (!feof (fp))
10987 {
10988 int n = fread (in, hccap_size, 1, fp);
10989
10990 if (n != 1)
10991 {
10992 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
10993
10994 break;
10995 }
10996
10997 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
10998
10999 if (parser_status != PARSER_OK)
11000 {
11001 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11002
11003 continue;
11004 }
11005
11006 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11007
11008 if ((show == 1) || (left == 1))
11009 {
11010 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11011
11012 char *salt_ptr = (char *) tmp_salt->salt_buf;
11013
11014 int cur_pos = tmp_salt->salt_len;
11015 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11016
11017 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11018
11019 // do the appending task
11020
11021 snprintf (salt_ptr + cur_pos,
11022 rem_len,
11023 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11024 wpa->orig_mac1[0],
11025 wpa->orig_mac1[1],
11026 wpa->orig_mac1[2],
11027 wpa->orig_mac1[3],
11028 wpa->orig_mac1[4],
11029 wpa->orig_mac1[5],
11030 wpa->orig_mac2[0],
11031 wpa->orig_mac2[1],
11032 wpa->orig_mac2[2],
11033 wpa->orig_mac2[3],
11034 wpa->orig_mac2[4],
11035 wpa->orig_mac2[5]);
11036
11037 // memset () the remaining part of the salt
11038
11039 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11040 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11041
11042 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11043
11044 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11045 }
11046
11047 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);
11048 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);
11049
11050 hashes_cnt++;
11051 }
11052
11053 fclose (fp);
11054
11055 myfree (in);
11056 }
11057 else if (hash_mode == 3000)
11058 {
11059 if (hash_len == 32)
11060 {
11061 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11062
11063 hash_t *lm_hash_left = NULL;
11064
11065 if (parser_status == PARSER_OK)
11066 {
11067 lm_hash_left = &hashes_buf[hashes_cnt];
11068
11069 hashes_cnt++;
11070 }
11071 else
11072 {
11073 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11074 }
11075
11076 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11077
11078 hash_t *lm_hash_right = NULL;
11079
11080 if (parser_status == PARSER_OK)
11081 {
11082 lm_hash_right = &hashes_buf[hashes_cnt];
11083
11084 hashes_cnt++;
11085 }
11086 else
11087 {
11088 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11089 }
11090
11091 // show / left
11092
11093 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11094 {
11095 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);
11096 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);
11097 }
11098 }
11099 else
11100 {
11101 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11102
11103 if (parser_status == PARSER_OK)
11104 {
11105 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11106 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11107 }
11108
11109 if (parser_status == PARSER_OK)
11110 {
11111 hashes_cnt++;
11112 }
11113 else
11114 {
11115 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11116 }
11117 }
11118 }
11119 else
11120 {
11121 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11122
11123 if (parser_status == PARSER_OK)
11124 {
11125 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11126 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11127 }
11128
11129 if (parser_status == PARSER_OK)
11130 {
11131 hashes_cnt++;
11132 }
11133 else
11134 {
11135 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11136 }
11137 }
11138 }
11139 }
11140 else if (hashlist_mode == HL_MODE_FILE)
11141 {
11142 char *hashfile = data.hashfile;
11143
11144 FILE *fp;
11145
11146 if ((fp = fopen (hashfile, "rb")) == NULL)
11147 {
11148 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11149
11150 return (-1);
11151 }
11152
11153 uint line_num = 0;
11154
11155 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11156
11157 while (!feof (fp))
11158 {
11159 line_num++;
11160
11161 int line_len = fgetl (fp, line_buf);
11162
11163 if (line_len == 0) continue;
11164
11165 char *hash_buf = NULL;
11166 int hash_len = 0;
11167
11168 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11169
11170 bool hash_fmt_error = 0;
11171
11172 if (hash_len < 1) hash_fmt_error = 1;
11173 if (hash_buf == NULL) hash_fmt_error = 1;
11174
11175 if (hash_fmt_error)
11176 {
11177 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11178
11179 continue;
11180 }
11181
11182 if (username)
11183 {
11184 char *user_buf = NULL;
11185 int user_len = 0;
11186
11187 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11188
11189 if (remove || show)
11190 {
11191 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11192
11193 *user = (user_t *) mymalloc (sizeof (user_t));
11194
11195 user_t *user_ptr = *user;
11196
11197 if (user_buf != NULL)
11198 {
11199 user_ptr->user_name = mystrdup (user_buf);
11200 }
11201 else
11202 {
11203 user_ptr->user_name = mystrdup ("");
11204 }
11205
11206 user_ptr->user_len = user_len;
11207 }
11208 }
11209
11210 if (opts_type & OPTS_TYPE_HASH_COPY)
11211 {
11212 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11213
11214 hash_info_tmp->orighash = mystrdup (hash_buf);
11215 }
11216
11217 if (isSalted)
11218 {
11219 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11220 }
11221
11222 if (hash_mode == 3000)
11223 {
11224 if (hash_len == 32)
11225 {
11226 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11227
11228 if (parser_status < PARSER_GLOBAL_ZERO)
11229 {
11230 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11231
11232 continue;
11233 }
11234
11235 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11236
11237 hashes_cnt++;
11238
11239 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11240
11241 if (parser_status < PARSER_GLOBAL_ZERO)
11242 {
11243 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11244
11245 continue;
11246 }
11247
11248 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11249
11250 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);
11251
11252 hashes_cnt++;
11253
11254 // show / left
11255
11256 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);
11257 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);
11258 }
11259 else
11260 {
11261 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11262
11263 if (parser_status < PARSER_GLOBAL_ZERO)
11264 {
11265 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11266
11267 continue;
11268 }
11269
11270 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);
11271
11272 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11273 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11274
11275 hashes_cnt++;
11276 }
11277 }
11278 else
11279 {
11280 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11281
11282 if (parser_status < PARSER_GLOBAL_ZERO)
11283 {
11284 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11285
11286 continue;
11287 }
11288
11289 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);
11290
11291 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11292 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11293
11294 hashes_cnt++;
11295 }
11296 }
11297
11298 myfree (line_buf);
11299
11300 fclose (fp);
11301
11302 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11303
11304 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11305 }
11306 }
11307 else
11308 {
11309 if (isSalted)
11310 {
11311 hashes_buf[0].salt->salt_len = 8;
11312
11313 // special salt handling
11314
11315 switch (hash_mode)
11316 {
11317 case 1500: hashes_buf[0].salt->salt_len = 2;
11318 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
11319 break;
11320 case 1731: hashes_buf[0].salt->salt_len = 4;
11321 break;
11322 case 2410: hashes_buf[0].salt->salt_len = 4;
11323 break;
11324 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11325 break;
11326 case 3100: hashes_buf[0].salt->salt_len = 1;
11327 break;
11328 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11329 break;
11330 case 5800: hashes_buf[0].salt->salt_len = 16;
11331 break;
11332 case 6800: hashes_buf[0].salt->salt_len = 32;
11333 break;
11334 case 8400: hashes_buf[0].salt->salt_len = 40;
11335 break;
11336 case 8800: hashes_buf[0].salt->salt_len = 16;
11337 break;
11338 case 8900: hashes_buf[0].salt->salt_len = 16;
11339 hashes_buf[0].salt->scrypt_N = 1024;
11340 hashes_buf[0].salt->scrypt_r = 1;
11341 hashes_buf[0].salt->scrypt_p = 1;
11342 break;
11343 case 9100: hashes_buf[0].salt->salt_len = 16;
11344 break;
11345 case 9300: hashes_buf[0].salt->salt_len = 14;
11346 hashes_buf[0].salt->scrypt_N = 16384;
11347 hashes_buf[0].salt->scrypt_r = 1;
11348 hashes_buf[0].salt->scrypt_p = 1;
11349 break;
11350 case 9400: hashes_buf[0].salt->salt_len = 16;
11351 break;
11352 case 9500: hashes_buf[0].salt->salt_len = 16;
11353 break;
11354 case 9600: hashes_buf[0].salt->salt_len = 16;
11355 break;
11356 case 9700: hashes_buf[0].salt->salt_len = 16;
11357 break;
11358 case 9710: hashes_buf[0].salt->salt_len = 16;
11359 break;
11360 case 9720: hashes_buf[0].salt->salt_len = 16;
11361 break;
11362 case 9800: hashes_buf[0].salt->salt_len = 16;
11363 break;
11364 case 9810: hashes_buf[0].salt->salt_len = 16;
11365 break;
11366 case 9820: hashes_buf[0].salt->salt_len = 16;
11367 break;
11368 case 10300: hashes_buf[0].salt->salt_len = 12;
11369 break;
11370 case 11500: hashes_buf[0].salt->salt_len = 4;
11371 break;
11372 case 11600: hashes_buf[0].salt->salt_len = 4;
11373 break;
11374 case 12400: hashes_buf[0].salt->salt_len = 4;
11375 break;
11376 case 12500: hashes_buf[0].salt->salt_len = 8;
11377 break;
11378 case 12600: hashes_buf[0].salt->salt_len = 64;
11379 break;
11380 }
11381
11382 // special esalt handling
11383
11384 switch (hash_mode)
11385 {
11386 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11387 break;
11388 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11389 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11390 break;
11391 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11392 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11393 break;
11394 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11395 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11396 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11397 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11398 break;
11399 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11400 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11401 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11402 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11403 break;
11404 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11405 break;
11406 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11407 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11408 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11409 break;
11410 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11411 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11412 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11413 break;
11414 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11415 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11416 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11417 break;
11418 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11419 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11420 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11421 break;
11422 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11423 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11424 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11425 break;
11426 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11427 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11428 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11429 break;
11430 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11431 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11432 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11433 break;
11434 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
11435 break;
11436 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
11437 break;
11438 }
11439 }
11440
11441 // set hashfile
11442
11443 switch (hash_mode)
11444 {
11445 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11446 break;
11447 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11448 break;
11449 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11450 break;
11451 case 6211: data.hashfile = mystrdup ("hashcat.tc");
11452 break;
11453 case 6212: data.hashfile = mystrdup ("hashcat.tc");
11454 break;
11455 case 6213: data.hashfile = mystrdup ("hashcat.tc");
11456 break;
11457 case 6221: data.hashfile = mystrdup ("hashcat.tc");
11458 break;
11459 case 6222: data.hashfile = mystrdup ("hashcat.tc");
11460 break;
11461 case 6223: data.hashfile = mystrdup ("hashcat.tc");
11462 break;
11463 case 6231: data.hashfile = mystrdup ("hashcat.tc");
11464 break;
11465 case 6232: data.hashfile = mystrdup ("hashcat.tc");
11466 break;
11467 case 6233: data.hashfile = mystrdup ("hashcat.tc");
11468 break;
11469 case 6241: data.hashfile = mystrdup ("hashcat.tc");
11470 break;
11471 case 6242: data.hashfile = mystrdup ("hashcat.tc");
11472 break;
11473 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11474 break;
11475 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11476 break;
11477 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11478 break;
11479 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11480 break;
11481 }
11482
11483 // set default iterations
11484
11485 switch (hash_mode)
11486 {
11487 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11488 break;
11489 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11490 break;
11491 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11492 break;
11493 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11494 break;
11495 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11496 break;
11497 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11498 break;
11499 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11500 break;
11501 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11502 break;
11503 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11504 break;
11505 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11506 break;
11507 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11508 break;
11509 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11510 break;
11511 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11512 break;
11513 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11514 break;
11515 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11516 break;
11517 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11518 break;
11519 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11520 break;
11521 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11522 break;
11523 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11524 break;
11525 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11526 break;
11527 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11528 break;
11529 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11530 break;
11531 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11532 break;
11533 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11534 break;
11535 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11536 break;
11537 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11538 break;
11539 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11540 break;
11541 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11542 break;
11543 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11544 break;
11545 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11546 break;
11547 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11548 break;
11549 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11550 break;
11551 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11552 break;
11553 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11554 break;
11555 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11556 break;
11557 case 8900: hashes_buf[0].salt->salt_iter = 1;
11558 break;
11559 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11560 break;
11561 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11562 break;
11563 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11564 break;
11565 case 9300: hashes_buf[0].salt->salt_iter = 1;
11566 break;
11567 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11568 break;
11569 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11570 break;
11571 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11572 break;
11573 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11574 break;
11575 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11576 break;
11577 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11578 break;
11579 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11580 break;
11581 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11582 break;
11583 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11584 break;
11585 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11586 break;
11587 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11588 break;
11589 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11590 break;
11591 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11592 break;
11593 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11594 break;
11595 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11596 break;
11597 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11598 break;
11599 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11600 break;
11601 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11602 break;
11603 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11604 break;
11605 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11606 break;
11607 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11608 break;
11609 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
11610 break;
11611 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
11612 break;
11613 }
11614
11615 hashes_cnt = 1;
11616 }
11617
11618 if (show == 1 || left == 1)
11619 {
11620 for (uint i = 0; i < pot_cnt; i++)
11621 {
11622 pot_t *pot_ptr = &pot[i];
11623
11624 hash_t *hashes_buf = &pot_ptr->hash;
11625
11626 local_free (hashes_buf->digest);
11627
11628 if (isSalted)
11629 {
11630 local_free (hashes_buf->salt);
11631 }
11632 }
11633
11634 local_free (pot);
11635
11636 if (data.quiet == 0) log_info_nn ("");
11637
11638 return (0);
11639 }
11640
11641 if (keyspace == 0)
11642 {
11643 if (hashes_cnt == 0)
11644 {
11645 log_error ("ERROR: No hashes loaded");
11646
11647 return (-1);
11648 }
11649 }
11650
11651 /**
11652 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11653 */
11654
11655 if (data.outfile != NULL)
11656 {
11657 if (data.hashfile != NULL)
11658 {
11659 #ifdef _POSIX
11660 struct stat tmpstat_outfile;
11661 struct stat tmpstat_hashfile;
11662 #endif
11663
11664 #ifdef _WIN
11665 struct stat64 tmpstat_outfile;
11666 struct stat64 tmpstat_hashfile;
11667 #endif
11668
11669 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11670
11671 if (tmp_outfile_fp)
11672 {
11673 #ifdef _POSIX
11674 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11675 #endif
11676
11677 #ifdef _WIN
11678 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11679 #endif
11680
11681 fclose (tmp_outfile_fp);
11682 }
11683
11684 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11685
11686 if (tmp_hashfile_fp)
11687 {
11688 #ifdef _POSIX
11689 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11690 #endif
11691
11692 #ifdef _WIN
11693 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11694 #endif
11695
11696 fclose (tmp_hashfile_fp);
11697 }
11698
11699 if (tmp_outfile_fp && tmp_outfile_fp)
11700 {
11701 tmpstat_outfile.st_mode = 0;
11702 tmpstat_outfile.st_nlink = 0;
11703 tmpstat_outfile.st_uid = 0;
11704 tmpstat_outfile.st_gid = 0;
11705 tmpstat_outfile.st_rdev = 0;
11706 tmpstat_outfile.st_atime = 0;
11707
11708 tmpstat_hashfile.st_mode = 0;
11709 tmpstat_hashfile.st_nlink = 0;
11710 tmpstat_hashfile.st_uid = 0;
11711 tmpstat_hashfile.st_gid = 0;
11712 tmpstat_hashfile.st_rdev = 0;
11713 tmpstat_hashfile.st_atime = 0;
11714
11715 #ifdef _POSIX
11716 tmpstat_outfile.st_blksize = 0;
11717 tmpstat_outfile.st_blocks = 0;
11718
11719 tmpstat_hashfile.st_blksize = 0;
11720 tmpstat_hashfile.st_blocks = 0;
11721 #endif
11722
11723 #ifdef _POSIX
11724 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11725 {
11726 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11727
11728 return (-1);
11729 }
11730 #endif
11731
11732 #ifdef _WIN
11733 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11734 {
11735 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11736
11737 return (-1);
11738 }
11739 #endif
11740 }
11741 }
11742 }
11743
11744 /**
11745 * Remove duplicates
11746 */
11747
11748 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11749
11750 if (isSalted)
11751 {
11752 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11753 }
11754 else
11755 {
11756 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11757 }
11758
11759 uint hashes_cnt_orig = hashes_cnt;
11760
11761 hashes_cnt = 1;
11762
11763 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11764 {
11765 if (isSalted)
11766 {
11767 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11768 {
11769 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11770 }
11771 }
11772 else
11773 {
11774 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11775 }
11776
11777 if (hashes_pos > hashes_cnt)
11778 {
11779 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11780 }
11781
11782 hashes_cnt++;
11783 }
11784
11785 /**
11786 * Potfile removes
11787 */
11788
11789 uint potfile_remove_cracks = 0;
11790
11791 if (potfile_disable == 0)
11792 {
11793 hash_t hash_buf;
11794
11795 hash_buf.digest = mymalloc (dgst_size);
11796 hash_buf.salt = NULL;
11797 hash_buf.esalt = NULL;
11798 hash_buf.hash_info = NULL;
11799 hash_buf.cracked = 0;
11800
11801 if (isSalted)
11802 {
11803 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11804 }
11805
11806 if (esalt_size)
11807 {
11808 hash_buf.esalt = mymalloc (esalt_size);
11809 }
11810
11811 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11812
11813 // no solution for these special hash types (for instane because they use hashfile in output etc)
11814 if ((hash_mode != 5200) &&
11815 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11816 (hash_mode != 9000))
11817 {
11818 FILE *fp = fopen (potfile, "rb");
11819
11820 if (fp != NULL)
11821 {
11822 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11823
11824 // to be safe work with a copy (because of line_len loop, i etc)
11825 // moved up here because it's easier to handle continue case
11826 // it's just 64kb
11827
11828 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
11829
11830 while (!feof (fp))
11831 {
11832 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
11833
11834 if (ptr == NULL) break;
11835
11836 int line_len = strlen (line_buf);
11837
11838 if (line_len == 0) continue;
11839
11840 int iter = MAX_CUT_TRIES;
11841
11842 for (int i = line_len - 1; i && iter; i--, line_len--)
11843 {
11844 if (line_buf[i] != ':') continue;
11845
11846 if (isSalted)
11847 {
11848 memset (hash_buf.salt, 0, sizeof (salt_t));
11849 }
11850
11851 hash_t *found = NULL;
11852
11853 if (hash_mode == 6800)
11854 {
11855 if (i < 64) // 64 = 16 * uint in salt_buf[]
11856 {
11857 // manipulate salt_buf
11858 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11859
11860 hash_buf.salt->salt_len = i;
11861
11862 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11863 }
11864 }
11865 else if (hash_mode == 2500)
11866 {
11867 if (i < 64) // 64 = 16 * uint in salt_buf[]
11868 {
11869 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11870 // manipulate salt_buf
11871
11872 memcpy (line_buf_cpy, line_buf, i);
11873
11874 char *mac2_pos = strrchr (line_buf_cpy, ':');
11875
11876 if (mac2_pos == NULL) continue;
11877
11878 mac2_pos[0] = 0;
11879 mac2_pos++;
11880
11881 if (strlen (mac2_pos) != 12) continue;
11882
11883 char *mac1_pos = strrchr (line_buf_cpy, ':');
11884
11885 if (mac1_pos == NULL) continue;
11886
11887 mac1_pos[0] = 0;
11888 mac1_pos++;
11889
11890 if (strlen (mac1_pos) != 12) continue;
11891
11892 uint essid_length = mac1_pos - line_buf_cpy - 1;
11893
11894 // here we need the ESSID
11895 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11896
11897 hash_buf.salt->salt_len = essid_length;
11898
11899 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11900
11901 if (found)
11902 {
11903 wpa_t *wpa = (wpa_t *) found->esalt;
11904
11905 // compare hex string(s) vs binary MAC address(es)
11906
11907 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11908 {
11909 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
11910 {
11911 found = NULL;
11912
11913 break;
11914 }
11915 }
11916
11917 // early skip ;)
11918 if (!found) continue;
11919
11920 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11921 {
11922 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
11923 {
11924 found = NULL;
11925
11926 break;
11927 }
11928 }
11929 }
11930 }
11931 }
11932 else
11933 {
11934 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
11935
11936 if (parser_status == PARSER_OK)
11937 {
11938 if (isSalted)
11939 {
11940 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11941 }
11942 else
11943 {
11944 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11945 }
11946 }
11947 }
11948
11949 if (found == NULL) continue;
11950
11951 if (!found->cracked) potfile_remove_cracks++;
11952
11953 found->cracked = 1;
11954
11955 if (found) break;
11956
11957 iter--;
11958 }
11959 }
11960
11961 myfree (line_buf_cpy);
11962
11963 myfree (line_buf);
11964
11965 fclose (fp);
11966 }
11967 }
11968
11969 if (esalt_size)
11970 {
11971 local_free (hash_buf.esalt);
11972 }
11973
11974 if (isSalted)
11975 {
11976 local_free (hash_buf.salt);
11977 }
11978
11979 local_free (hash_buf.digest);
11980 }
11981
11982 /**
11983 * Now generate all the buffers required for later
11984 */
11985
11986 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
11987
11988 salt_t *salts_buf_new = NULL;
11989 void *esalts_buf_new = NULL;
11990
11991 if (isSalted)
11992 {
11993 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11994
11995 if (esalt_size)
11996 {
11997 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
11998 }
11999 }
12000 else
12001 {
12002 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12003 }
12004
12005 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12006
12007 uint digests_cnt = hashes_cnt;
12008 uint digests_done = 0;
12009
12010 size_t size_digests = digests_cnt * dgst_size;
12011 size_t size_shown = digests_cnt * sizeof (uint);
12012
12013 uint *digests_shown = (uint *) mymalloc (size_shown);
12014 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12015
12016 uint salts_cnt = 0;
12017 uint salts_done = 0;
12018
12019 hashinfo_t **hash_info = NULL;
12020
12021 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12022 {
12023 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12024
12025 if (username && (remove || show))
12026 {
12027 uint user_pos;
12028
12029 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12030 {
12031 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12032
12033 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12034 }
12035 }
12036 }
12037
12038 uint *salts_shown = (uint *) mymalloc (size_shown);
12039
12040 salt_t *salt_buf;
12041
12042 {
12043 // copied from inner loop
12044
12045 salt_buf = &salts_buf_new[salts_cnt];
12046
12047 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12048
12049 if (esalt_size)
12050 {
12051 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12052 }
12053
12054 salt_buf->digests_cnt = 0;
12055 salt_buf->digests_done = 0;
12056 salt_buf->digests_offset = 0;
12057
12058 salts_cnt++;
12059 }
12060
12061 if (hashes_buf[0].cracked == 1)
12062 {
12063 digests_shown[0] = 1;
12064
12065 digests_done++;
12066
12067 salt_buf->digests_done++;
12068 }
12069
12070 salt_buf->digests_cnt++;
12071
12072 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12073
12074 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12075 {
12076 hash_info[0] = hashes_buf[0].hash_info;
12077 }
12078
12079 // copy from inner loop
12080
12081 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12082 {
12083 if (isSalted)
12084 {
12085 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12086 {
12087 salt_buf = &salts_buf_new[salts_cnt];
12088
12089 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12090
12091 if (esalt_size)
12092 {
12093 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12094 }
12095
12096 salt_buf->digests_cnt = 0;
12097 salt_buf->digests_done = 0;
12098 salt_buf->digests_offset = hashes_pos;
12099
12100 salts_cnt++;
12101 }
12102 }
12103
12104 if (hashes_buf[hashes_pos].cracked == 1)
12105 {
12106 digests_shown[hashes_pos] = 1;
12107
12108 digests_done++;
12109
12110 salt_buf->digests_done++;
12111 }
12112
12113 salt_buf->digests_cnt++;
12114
12115 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12116
12117 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12118 {
12119 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12120 }
12121 }
12122
12123 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12124 {
12125 salt_t *salt_buf = &salts_buf_new[salt_pos];
12126
12127 if (salt_buf->digests_done == salt_buf->digests_cnt)
12128 {
12129 salts_shown[salt_pos] = 1;
12130
12131 salts_done++;
12132 }
12133
12134 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12135 }
12136
12137 local_free (digests_buf);
12138 local_free (salts_buf);
12139 local_free (esalts_buf);
12140
12141 digests_buf = digests_buf_new;
12142 salts_buf = salts_buf_new;
12143 esalts_buf = esalts_buf_new;
12144
12145 local_free (hashes_buf);
12146
12147 /**
12148 * special modification not set from parser
12149 */
12150
12151 switch (hash_mode)
12152 {
12153 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12154 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12155 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12156 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12157 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12158 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12159 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12160 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12161 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12162 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12163 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12164 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12165 }
12166
12167 if (truecrypt_keyfiles)
12168 {
12169 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12170
12171 char *keyfiles = strdup (truecrypt_keyfiles);
12172
12173 char *keyfile = strtok (keyfiles, ",");
12174
12175 do
12176 {
12177 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12178
12179 } while ((keyfile = strtok (NULL, ",")) != NULL);
12180
12181 free (keyfiles);
12182 }
12183
12184 data.digests_cnt = digests_cnt;
12185 data.digests_done = digests_done;
12186 data.digests_buf = digests_buf;
12187 data.digests_shown = digests_shown;
12188 data.digests_shown_tmp = digests_shown_tmp;
12189
12190 data.salts_cnt = salts_cnt;
12191 data.salts_done = salts_done;
12192 data.salts_buf = salts_buf;
12193 data.salts_shown = salts_shown;
12194
12195 data.esalts_buf = esalts_buf;
12196 data.hash_info = hash_info;
12197
12198 /**
12199 * Automatic Optimizers
12200 */
12201
12202 if (salts_cnt == 1)
12203 opti_type |= OPTI_TYPE_SINGLE_SALT;
12204
12205 if (digests_cnt == 1)
12206 opti_type |= OPTI_TYPE_SINGLE_HASH;
12207
12208 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12209 opti_type |= OPTI_TYPE_NOT_ITERATED;
12210
12211 if (attack_mode == ATTACK_MODE_BF)
12212 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12213
12214 data.opti_type = opti_type;
12215
12216 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12217 {
12218 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12219 {
12220 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12221 {
12222 if (opts_type & OPTS_TYPE_ST_ADD80)
12223 {
12224 opts_type &= ~OPTS_TYPE_ST_ADD80;
12225 opts_type |= OPTS_TYPE_PT_ADD80;
12226 }
12227
12228 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12229 {
12230 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12231 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12232 }
12233
12234 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12235 {
12236 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12237 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12238 }
12239 }
12240 }
12241 }
12242
12243 /**
12244 * Some algorithm, like descrypt, can benefit from JIT compilation
12245 */
12246
12247 int force_jit_compilation = -1;
12248
12249 if (hash_mode == 8900)
12250 {
12251 force_jit_compilation = 8900;
12252 }
12253 else if (hash_mode == 9300)
12254 {
12255 force_jit_compilation = 8900;
12256 }
12257 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12258 {
12259 force_jit_compilation = 1500;
12260 }
12261
12262 /**
12263 * generate bitmap tables
12264 */
12265
12266 const uint bitmap_shift1 = 5;
12267 const uint bitmap_shift2 = 13;
12268
12269 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12270
12271 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12272 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12273 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12274 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12275 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12276 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12277 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12278 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12279
12280 uint bitmap_bits;
12281 uint bitmap_nums;
12282 uint bitmap_mask;
12283 uint bitmap_size;
12284
12285 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12286 {
12287 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12288
12289 bitmap_nums = 1 << bitmap_bits;
12290
12291 bitmap_mask = bitmap_nums - 1;
12292
12293 bitmap_size = bitmap_nums * sizeof (uint);
12294
12295 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12296
12297 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;
12298 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;
12299
12300 break;
12301 }
12302
12303 bitmap_nums = 1 << bitmap_bits;
12304
12305 bitmap_mask = bitmap_nums - 1;
12306
12307 bitmap_size = bitmap_nums * sizeof (uint);
12308
12309 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);
12310 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);
12311
12312 /**
12313 * prepare quick rule
12314 */
12315
12316 data.rule_buf_l = rule_buf_l;
12317 data.rule_buf_r = rule_buf_r;
12318
12319 int rule_len_l = (int) strlen (rule_buf_l);
12320 int rule_len_r = (int) strlen (rule_buf_r);
12321
12322 data.rule_len_l = rule_len_l;
12323 data.rule_len_r = rule_len_r;
12324
12325 /**
12326 * load rules
12327 */
12328
12329 uint *all_kernel_rules_cnt = NULL;
12330
12331 kernel_rule_t **all_kernel_rules_buf = NULL;
12332
12333 if (rp_files_cnt)
12334 {
12335 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12336
12337 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12338 }
12339
12340 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
12341
12342 int rule_len = 0;
12343
12344 for (uint i = 0; i < rp_files_cnt; i++)
12345 {
12346 uint kernel_rules_avail = 0;
12347
12348 uint kernel_rules_cnt = 0;
12349
12350 kernel_rule_t *kernel_rules_buf = NULL;
12351
12352 char *rp_file = rp_files[i];
12353
12354 char in[BLOCK_SIZE] = { 0 };
12355 char out[BLOCK_SIZE] = { 0 };
12356
12357 FILE *fp = NULL;
12358
12359 uint rule_line = 0;
12360
12361 if ((fp = fopen (rp_file, "rb")) == NULL)
12362 {
12363 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12364
12365 return (-1);
12366 }
12367
12368 while (!feof (fp))
12369 {
12370 memset (rule_buf, 0, HCBUFSIZ);
12371
12372 rule_len = fgetl (fp, rule_buf);
12373
12374 rule_line++;
12375
12376 if (rule_len == 0) continue;
12377
12378 if (rule_buf[0] == '#') continue;
12379
12380 if (kernel_rules_avail == kernel_rules_cnt)
12381 {
12382 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12383
12384 kernel_rules_avail += INCR_RULES;
12385 }
12386
12387 memset (in, 0, BLOCK_SIZE);
12388 memset (out, 0, BLOCK_SIZE);
12389
12390 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12391
12392 if (result == -1)
12393 {
12394 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12395
12396 continue;
12397 }
12398
12399 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12400 {
12401 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12402
12403 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12404
12405 continue;
12406 }
12407
12408 /* its so slow
12409 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12410 {
12411 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12412
12413 continue;
12414 }
12415 */
12416
12417 kernel_rules_cnt++;
12418 }
12419
12420 fclose (fp);
12421
12422 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12423
12424 all_kernel_rules_buf[i] = kernel_rules_buf;
12425 }
12426
12427 /**
12428 * merge rules or automatic rule generator
12429 */
12430
12431 uint kernel_rules_cnt = 0;
12432
12433 kernel_rule_t *kernel_rules_buf = NULL;
12434
12435 if (attack_mode == ATTACK_MODE_STRAIGHT)
12436 {
12437 if (rp_files_cnt)
12438 {
12439 kernel_rules_cnt = 1;
12440
12441 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12442
12443 repeats[0] = kernel_rules_cnt;
12444
12445 for (uint i = 0; i < rp_files_cnt; i++)
12446 {
12447 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12448
12449 repeats[i + 1] = kernel_rules_cnt;
12450 }
12451
12452 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12453
12454 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12455
12456 for (uint i = 0; i < kernel_rules_cnt; i++)
12457 {
12458 uint out_pos = 0;
12459
12460 kernel_rule_t *out = &kernel_rules_buf[i];
12461
12462 for (uint j = 0; j < rp_files_cnt; j++)
12463 {
12464 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12465 uint in_pos;
12466
12467 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12468
12469 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12470 {
12471 if (out_pos == RULES_MAX - 1)
12472 {
12473 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12474
12475 break;
12476 }
12477
12478 out->cmds[out_pos] = in->cmds[in_pos];
12479 }
12480 }
12481 }
12482
12483 local_free (repeats);
12484 }
12485 else if (rp_gen)
12486 {
12487 uint kernel_rules_avail = 0;
12488
12489 while (kernel_rules_cnt < rp_gen)
12490 {
12491 if (kernel_rules_avail == kernel_rules_cnt)
12492 {
12493 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12494
12495 kernel_rules_avail += INCR_RULES;
12496 }
12497
12498 memset (rule_buf, 0, HCBUFSIZ);
12499
12500 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12501
12502 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12503
12504 kernel_rules_cnt++;
12505 }
12506 }
12507 }
12508
12509 myfree (rule_buf);
12510
12511 /**
12512 * generate NOP rules
12513 */
12514
12515 if (kernel_rules_cnt == 0)
12516 {
12517 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12518
12519 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12520
12521 kernel_rules_cnt++;
12522 }
12523
12524 data.kernel_rules_cnt = kernel_rules_cnt;
12525 data.kernel_rules_buf = kernel_rules_buf;
12526
12527 /**
12528 * OpenCL platforms: detect
12529 */
12530
12531 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
12532 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
12533
12534 cl_uint platforms_cnt = 0;
12535 cl_uint platform_devices_cnt = 0;
12536
12537 if (keyspace == 0)
12538 {
12539 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12540
12541 if (platforms_cnt == 0)
12542 {
12543 log_info ("");
12544 log_info ("ATTENTION! No OpenCL compatible platform found");
12545 log_info ("");
12546 log_info ("You're probably missing the OpenCL runtime installation");
12547 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
12548 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
12549 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
12550 log_info ("");
12551
12552 return (-1);
12553 }
12554
12555 if (opencl_platforms_filter != (uint) -1)
12556 {
12557 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
12558
12559 if (opencl_platforms_filter > platform_cnt_mask)
12560 {
12561 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
12562
12563 return (-1);
12564 }
12565 }
12566 }
12567
12568 /**
12569 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12570 */
12571
12572 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12573 {
12574 cl_platform_id platform = platforms[platform_id];
12575
12576 char platform_vendor[INFOSZ] = { 0 };
12577
12578 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12579
12580 #ifdef HAVE_HWMON
12581 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12582 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12583 {
12584 // make sure that we do not directly control the fan for NVidia
12585
12586 gpu_temp_retain = 0;
12587
12588 data.gpu_temp_retain = gpu_temp_retain;
12589 }
12590 #endif // HAVE_NVML || HAVE_NVAPI
12591 #endif
12592 }
12593
12594 /**
12595 * OpenCL device types:
12596 * In case the user did not specify --opencl-device-types and the user runs hashcat in a system with only a CPU only he probably want to use that CPU.
12597 * In such a case, automatically enable CPU device type support, since it's disabled by default.
12598 */
12599
12600 if (opencl_device_types == NULL)
12601 {
12602 cl_device_type device_types_all = 0;
12603
12604 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12605 {
12606 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12607
12608 cl_platform_id platform = platforms[platform_id];
12609
12610 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12611
12612 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12613 {
12614 cl_device_id device = platform_devices[platform_devices_id];
12615
12616 cl_device_type device_type;
12617
12618 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12619
12620 device_types_all |= device_type;
12621 }
12622 }
12623
12624 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
12625 {
12626 device_types_filter |= CL_DEVICE_TYPE_CPU;
12627 }
12628 }
12629
12630 /**
12631 * OpenCL devices: simply push all devices from all platforms into the same device array
12632 */
12633
12634 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12635
12636 data.devices_param = devices_param;
12637
12638 uint devices_cnt = 0;
12639
12640 uint devices_active = 0;
12641
12642 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12643 {
12644 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12645
12646 cl_platform_id platform = platforms[platform_id];
12647
12648 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12649
12650 char platform_vendor[INFOSZ] = { 0 };
12651
12652 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12653
12654 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
12655 // this causes trouble with vendor id based macros
12656 // we'll assign generic to those without special optimization available
12657
12658 cl_uint vendor_id = 0;
12659
12660 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
12661 {
12662 vendor_id = VENDOR_ID_AMD;
12663 }
12664 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
12665 {
12666 vendor_id = VENDOR_ID_GENERIC;
12667 }
12668 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
12669 {
12670 vendor_id = VENDOR_ID_GENERIC;
12671 }
12672 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
12673 {
12674 vendor_id = VENDOR_ID_GENERIC;
12675 }
12676 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
12677 {
12678 vendor_id = VENDOR_ID_GENERIC;
12679 }
12680 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12681 {
12682 vendor_id = VENDOR_ID_NV;
12683 }
12684 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
12685 {
12686 vendor_id = VENDOR_ID_GENERIC;
12687 }
12688 else
12689 {
12690 vendor_id = VENDOR_ID_GENERIC;
12691 }
12692
12693 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12694 {
12695 size_t param_value_size = 0;
12696
12697 const uint device_id = devices_cnt;
12698
12699 hc_device_param_t *device_param = &data.devices_param[device_id];
12700
12701 device_param->vendor_id = vendor_id;
12702
12703 device_param->device = platform_devices[platform_devices_id];
12704
12705 device_param->device_id = device_id;
12706
12707 device_param->platform_devices_id = platform_devices_id;
12708
12709 // device_type
12710
12711 cl_device_type device_type;
12712
12713 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12714
12715 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12716
12717 device_param->device_type = device_type;
12718
12719 // device_name
12720
12721 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
12722
12723 char *device_name = (char *) mymalloc (param_value_size);
12724
12725 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
12726
12727 device_param->device_name = device_name;
12728
12729 // tuning db
12730
12731 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
12732
12733 // device_version
12734
12735 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
12736
12737 char *device_version = (char *) mymalloc (param_value_size);
12738
12739 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
12740
12741 device_param->device_version = device_version;
12742
12743 // device_opencl_version
12744
12745 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
12746
12747 char *device_opencl_version = (char *) mymalloc (param_value_size);
12748
12749 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
12750
12751 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
12752
12753 myfree (device_opencl_version);
12754
12755 // vector_width
12756
12757 cl_uint vector_width;
12758
12759 if (opencl_vector_width_chgd == 0)
12760 {
12761 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
12762 {
12763 if (opti_type & OPTI_TYPE_USES_BITS_64)
12764 {
12765 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
12766 }
12767 else
12768 {
12769 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12770 }
12771 }
12772 else
12773 {
12774 vector_width = (cl_uint) tuningdb_entry->vector_width;
12775 }
12776 }
12777 else
12778 {
12779 vector_width = opencl_vector_width;
12780 }
12781
12782 if (vector_width > 16) vector_width = 16;
12783
12784 device_param->vector_width = vector_width;
12785
12786 // max_compute_units
12787
12788 cl_uint device_processors;
12789
12790 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12791
12792 device_param->device_processors = device_processors;
12793
12794 // device_maxmem_alloc
12795 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
12796
12797 cl_ulong device_maxmem_alloc;
12798
12799 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12800
12801 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
12802
12803 // device_global_mem
12804
12805 cl_ulong device_global_mem;
12806
12807 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12808
12809 device_param->device_global_mem = device_global_mem;
12810
12811 // max_work_group_size
12812
12813 size_t device_maxworkgroup_size;
12814
12815 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
12816
12817 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
12818
12819 // max_clock_frequency
12820
12821 cl_uint device_maxclock_frequency;
12822
12823 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12824
12825 device_param->device_maxclock_frequency = device_maxclock_frequency;
12826
12827 // device_endian_little
12828
12829 cl_bool device_endian_little;
12830
12831 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
12832
12833 if (device_endian_little == CL_FALSE)
12834 {
12835 log_info ("Device #%u: WARNING: not little endian device", device_id + 1);
12836
12837 device_param->skipped = 1;
12838 }
12839
12840 // device_available
12841
12842 cl_bool device_available;
12843
12844 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
12845
12846 if (device_available == CL_FALSE)
12847 {
12848 log_info ("Device #%u: WARNING: device not available", device_id + 1);
12849
12850 device_param->skipped = 1;
12851 }
12852
12853 // device_compiler_available
12854
12855 cl_bool device_compiler_available;
12856
12857 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
12858
12859 if (device_compiler_available == CL_FALSE)
12860 {
12861 log_info ("Device #%u: WARNING: device no compiler available", device_id + 1);
12862
12863 device_param->skipped = 1;
12864 }
12865
12866 // device_execution_capabilities
12867
12868 cl_device_exec_capabilities device_execution_capabilities;
12869
12870 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
12871
12872 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
12873 {
12874 log_info ("Device #%u: WARNING: device does not support executing kernels", device_id + 1);
12875
12876 device_param->skipped = 1;
12877 }
12878
12879 // device_extensions
12880
12881 size_t device_extensions_size;
12882
12883 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
12884
12885 char *device_extensions = mymalloc (device_extensions_size + 1);
12886
12887 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
12888
12889 if (strstr (device_extensions, "base_atomics") == 0)
12890 {
12891 log_info ("Device #%u: WARNING: device does not support base atomics", device_id + 1);
12892
12893 device_param->skipped = 1;
12894 }
12895
12896 if (strstr (device_extensions, "byte_addressable_store") == 0)
12897 {
12898 log_info ("Device #%u: WARNING: device does not support byte addressable store", device_id + 1);
12899
12900 device_param->skipped = 1;
12901 }
12902
12903 myfree (device_extensions);
12904
12905 // device_local_mem_size
12906
12907 cl_ulong device_local_mem_size;
12908
12909 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
12910
12911 if (device_local_mem_size < 32768)
12912 {
12913 log_info ("Device #%u: WARNING: device local mem size is too small", device_id + 1);
12914
12915 device_param->skipped = 1;
12916 }
12917
12918
12919 // skipped
12920
12921 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
12922 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
12923
12924 // driver_version
12925
12926 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
12927
12928 char *driver_version = (char *) mymalloc (param_value_size);
12929
12930 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
12931
12932 device_param->driver_version = driver_version;
12933
12934 // device_name_chksum
12935
12936 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12937
12938 #if __x86_64__
12939 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);
12940 #else
12941 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);
12942 #endif
12943
12944 uint device_name_digest[4] = { 0 };
12945
12946 md5_64 ((uint *) device_name_chksum, device_name_digest);
12947
12948 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
12949
12950 device_param->device_name_chksum = device_name_chksum;
12951
12952 // device_processor_cores
12953
12954 if (device_type & CL_DEVICE_TYPE_CPU)
12955 {
12956 cl_uint device_processor_cores = 1;
12957
12958 device_param->device_processor_cores = device_processor_cores;
12959 }
12960
12961 if (device_type & CL_DEVICE_TYPE_GPU)
12962 {
12963 if (vendor_id == VENDOR_ID_AMD)
12964 {
12965 cl_uint device_processor_cores = 0;
12966
12967 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12968
12969 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12970
12971 device_param->device_processor_cores = device_processor_cores;
12972 }
12973 else if (vendor_id == VENDOR_ID_NV)
12974 {
12975 cl_uint kernel_exec_timeout = 0;
12976
12977 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12978
12979 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12980
12981 device_param->kernel_exec_timeout = kernel_exec_timeout;
12982
12983 cl_uint device_processor_cores = 0;
12984
12985 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12986
12987 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12988
12989 device_param->device_processor_cores = device_processor_cores;
12990
12991 cl_uint sm_minor = 0;
12992 cl_uint sm_major = 0;
12993
12994 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12995 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12996
12997 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12998 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12999
13000 device_param->sm_minor = sm_minor;
13001 device_param->sm_major = sm_major;
13002 }
13003 else
13004 {
13005 cl_uint device_processor_cores = 1;
13006
13007 device_param->device_processor_cores = device_processor_cores;
13008 }
13009 }
13010
13011 // display results
13012
13013 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13014 {
13015 if (device_param->skipped == 0)
13016 {
13017 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
13018 device_id + 1,
13019 device_name,
13020 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
13021 (unsigned int) (device_global_mem / 1024 / 1024),
13022 (unsigned int) (device_maxclock_frequency),
13023 (unsigned int) device_processors);
13024 }
13025 else
13026 {
13027 log_info ("Device #%u: %s, skipped",
13028 device_id + 1,
13029 device_name);
13030 }
13031 }
13032
13033 // common driver check
13034
13035 if (device_param->skipped == 0)
13036 {
13037 if (device_type & CL_DEVICE_TYPE_GPU)
13038 {
13039 if (vendor_id == VENDOR_ID_AMD)
13040 {
13041 int catalyst_check = (force == 1) ? 0 : 1;
13042
13043 int catalyst_warn = 0;
13044
13045 int catalyst_broken = 0;
13046
13047 if (catalyst_check == 1)
13048 {
13049 catalyst_warn = 1;
13050
13051 // v14.9 and higher
13052 if (atoi (device_param->driver_version) >= 1573)
13053 {
13054 catalyst_warn = 0;
13055 }
13056
13057 catalyst_check = 0;
13058 }
13059
13060 if (catalyst_broken == 1)
13061 {
13062 log_info ("");
13063 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
13064 log_info ("It will pass over cracked hashes and does not report them as cracked");
13065 log_info ("You are STRONGLY encouraged not to use it");
13066 log_info ("You can use --force to override this but do not post error reports if you do so");
13067 log_info ("");
13068
13069 return (-1);
13070 }
13071
13072 if (catalyst_warn == 1)
13073 {
13074 log_info ("");
13075 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13076 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13077 log_info ("See hashcat's homepage for official supported catalyst drivers");
13078 #ifdef _WIN
13079 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13080 #endif
13081 log_info ("You can use --force to override this but do not post error reports if you do so");
13082 log_info ("");
13083
13084 return (-1);
13085 }
13086 }
13087 else if (vendor_id == VENDOR_ID_NV)
13088 {
13089 if (device_param->kernel_exec_timeout != 0)
13090 {
13091 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);
13092 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
13093 }
13094 }
13095 }
13096
13097 if (device_type & CL_DEVICE_TYPE_CPU)
13098 {
13099 if (vendor_id == VENDOR_ID_AMD)
13100 {
13101 if (force == 0)
13102 {
13103 log_info ("");
13104 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
13105 log_info ("You are STRONGLY encouraged not to use it");
13106 log_info ("You can use --force to override this but do not post error reports if you do so");
13107 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
13108 log_info ("");
13109
13110 return (-1);
13111 }
13112 }
13113 }
13114
13115 /**
13116 * kernel accel and loops tuning db adjustment
13117 */
13118
13119 device_param->kernel_accel_min = 1;
13120 device_param->kernel_accel_max = 1024;
13121
13122 device_param->kernel_loops_min = 1;
13123 device_param->kernel_loops_max = 1024;
13124
13125 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13126
13127 if (tuningdb_entry)
13128 {
13129 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13130 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13131
13132 if (_kernel_accel)
13133 {
13134 device_param->kernel_accel_min = _kernel_accel;
13135 device_param->kernel_accel_max = _kernel_accel;
13136 }
13137
13138 if (_kernel_loops)
13139 {
13140 if (workload_profile == 1)
13141 {
13142 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13143 }
13144 else if (workload_profile == 2)
13145 {
13146 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13147 }
13148
13149 device_param->kernel_loops_min = _kernel_loops;
13150 device_param->kernel_loops_max = _kernel_loops;
13151 }
13152 }
13153
13154 // commandline parameters overwrite tuningdb entries
13155
13156 if (kernel_accel)
13157 {
13158 device_param->kernel_accel_min = kernel_accel;
13159 device_param->kernel_accel_max = kernel_accel;
13160 }
13161
13162 if (kernel_loops)
13163 {
13164 device_param->kernel_loops_min = kernel_loops;
13165 device_param->kernel_loops_max = kernel_loops;
13166 }
13167
13168 /**
13169 * activate device
13170 */
13171
13172 devices_active++;
13173 }
13174
13175 // next please
13176
13177 devices_cnt++;
13178 }
13179 }
13180
13181 if (keyspace == 0 && devices_active == 0)
13182 {
13183 log_error ("ERROR: No devices found/left");
13184
13185 return (-1);
13186 }
13187
13188 // 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)
13189
13190 if (devices_filter != (uint) -1)
13191 {
13192 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
13193
13194 if (devices_filter > devices_cnt_mask)
13195 {
13196 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
13197
13198 return (-1);
13199 }
13200 }
13201
13202 data.devices_cnt = devices_cnt;
13203
13204 data.devices_active = devices_active;
13205
13206 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13207 {
13208 log_info ("");
13209 }
13210
13211 /**
13212 * HM devices: init
13213 */
13214
13215 #ifdef HAVE_HWMON
13216 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13217 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13218 #endif
13219
13220 #ifdef HAVE_ADL
13221 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13222 #endif
13223
13224 if (gpu_temp_disable == 0)
13225 {
13226 #if defined(WIN) && defined(HAVE_NVAPI)
13227 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13228
13229 if (nvapi_init (nvapi) == 0)
13230 data.hm_nv = nvapi;
13231
13232 if (data.hm_nv)
13233 {
13234 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13235 {
13236 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13237
13238 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13239
13240 int tmp_out = 0;
13241
13242 for (int i = 0; i < tmp_in; i++)
13243 {
13244 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13245 }
13246
13247 for (int i = 0; i < tmp_out; i++)
13248 {
13249 NV_GPU_COOLER_SETTINGS pCoolerSettings;
13250
13251 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
13252
13253 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;
13254 }
13255 }
13256 }
13257 #endif // WIN && HAVE_NVAPI
13258
13259 #if defined(LINUX) && defined(HAVE_NVML)
13260 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13261
13262 if (nvml_init (nvml) == 0)
13263 data.hm_nv = nvml;
13264
13265 if (data.hm_nv)
13266 {
13267 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13268 {
13269 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13270
13271 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13272
13273 int tmp_out = 0;
13274
13275 for (int i = 0; i < tmp_in; i++)
13276 {
13277 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13278 }
13279
13280 for (int i = 0; i < tmp_out; i++)
13281 {
13282 unsigned int speed;
13283
13284 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;
13285 }
13286 }
13287 }
13288 #endif // LINUX && HAVE_NVML
13289
13290 data.hm_amd = NULL;
13291
13292 #ifdef HAVE_ADL
13293 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13294
13295 if (adl_init (adl) == 0)
13296 data.hm_amd = adl;
13297
13298 if (data.hm_amd)
13299 {
13300 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13301 {
13302 // total number of adapters
13303
13304 int hm_adapters_num;
13305
13306 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13307
13308 // adapter info
13309
13310 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13311
13312 if (lpAdapterInfo == NULL) return (-1);
13313
13314 // get a list (of ids of) valid/usable adapters
13315
13316 int num_adl_adapters = 0;
13317
13318 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13319
13320 if (num_adl_adapters > 0)
13321 {
13322 hc_thread_mutex_lock (mux_adl);
13323
13324 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13325
13326 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13327
13328 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13329 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13330
13331 hc_thread_mutex_unlock (mux_adl);
13332 }
13333
13334 myfree (valid_adl_device_list);
13335 myfree (lpAdapterInfo);
13336 }
13337 }
13338 #endif // HAVE_ADL
13339
13340 if (data.hm_amd == NULL && data.hm_nv == NULL)
13341 {
13342 gpu_temp_disable = 1;
13343 }
13344 }
13345
13346 /**
13347 * OpenCL devices: allocate buffer for device specific information
13348 */
13349
13350 #ifdef HAVE_HWMON
13351 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13352
13353 #ifdef HAVE_ADL
13354 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13355
13356 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13357 #endif // ADL
13358 #endif
13359
13360 /**
13361 * enable custom signal handler(s)
13362 */
13363
13364 if (benchmark == 0)
13365 {
13366 hc_signal (sigHandler_default);
13367 }
13368 else
13369 {
13370 hc_signal (sigHandler_benchmark);
13371 }
13372
13373 /**
13374 * User-defined GPU temp handling
13375 */
13376
13377 #ifdef HAVE_HWMON
13378 if (gpu_temp_disable == 1)
13379 {
13380 gpu_temp_abort = 0;
13381 gpu_temp_retain = 0;
13382 }
13383
13384 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13385 {
13386 if (gpu_temp_abort < gpu_temp_retain)
13387 {
13388 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13389
13390 return (-1);
13391 }
13392 }
13393
13394 data.gpu_temp_disable = gpu_temp_disable;
13395 data.gpu_temp_abort = gpu_temp_abort;
13396 data.gpu_temp_retain = gpu_temp_retain;
13397 #endif
13398
13399 /**
13400 * inform the user
13401 */
13402
13403 if (data.quiet == 0)
13404 {
13405 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13406
13407 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);
13408
13409 if (attack_mode == ATTACK_MODE_STRAIGHT)
13410 {
13411 log_info ("Rules: %u", kernel_rules_cnt);
13412 }
13413
13414 if (opti_type)
13415 {
13416 log_info ("Applicable Optimizers:");
13417
13418 for (uint i = 0; i < 32; i++)
13419 {
13420 const uint opti_bit = 1u << i;
13421
13422 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13423 }
13424 }
13425
13426 /**
13427 * Watchdog and Temperature balance
13428 */
13429
13430 #ifdef HAVE_HWMON
13431 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13432 {
13433 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13434 }
13435
13436 if (gpu_temp_abort == 0)
13437 {
13438 log_info ("Watchdog: Temperature abort trigger disabled");
13439 }
13440 else
13441 {
13442 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13443 }
13444
13445 if (gpu_temp_retain == 0)
13446 {
13447 log_info ("Watchdog: Temperature retain trigger disabled");
13448 }
13449 else
13450 {
13451 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13452 }
13453 #endif
13454 }
13455
13456 if (data.quiet == 0) log_info ("");
13457
13458 /**
13459 * HM devices: copy
13460 */
13461
13462 if (gpu_temp_disable == 0)
13463 {
13464 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13465 {
13466 hc_device_param_t *device_param = &data.devices_param[device_id];
13467
13468 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13469
13470 if (device_param->skipped) continue;
13471
13472 const uint platform_devices_id = device_param->platform_devices_id;
13473
13474 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13475 if (device_param->vendor_id == VENDOR_ID_NV)
13476 {
13477 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13478 }
13479 #endif
13480
13481 #ifdef HAVE_ADL
13482 if (device_param->vendor_id == VENDOR_ID_AMD)
13483 {
13484 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13485 }
13486 #endif
13487 }
13488 }
13489
13490 /*
13491 * Temporary fix:
13492 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13493 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13494 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13495 * Driver / ADL bug?
13496 */
13497
13498 #ifdef HAVE_ADL
13499 if (powertune_enable == 1)
13500 {
13501 hc_thread_mutex_lock (mux_adl);
13502
13503 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13504 {
13505 hc_device_param_t *device_param = &data.devices_param[device_id];
13506
13507 if (device_param->skipped) continue;
13508
13509 if (data.hm_device[device_id].od_version == 6)
13510 {
13511 // set powertune value only
13512
13513 int powertune_supported = 0;
13514
13515 int ADL_rc = 0;
13516
13517 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13518 {
13519 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13520
13521 return (-1);
13522 }
13523
13524 if (powertune_supported != 0)
13525 {
13526 // powertune set
13527 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13528
13529 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13530 {
13531 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13532
13533 return (-1);
13534 }
13535
13536 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13537 {
13538 log_error ("ERROR: Failed to set new ADL PowerControl values");
13539
13540 return (-1);
13541 }
13542 }
13543 }
13544 }
13545
13546 hc_thread_mutex_unlock (mux_adl);
13547 }
13548 #endif // HAVE_ADK
13549 #endif // HAVE_HWMON
13550
13551 #ifdef DEBUG
13552 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
13553 #endif
13554
13555 uint kernel_power_all = 0;
13556
13557 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13558 {
13559 /**
13560 * host buffer
13561 */
13562
13563 hc_device_param_t *device_param = &data.devices_param[device_id];
13564
13565 if (device_param->skipped) continue;
13566
13567 /**
13568 * device properties
13569 */
13570
13571 const char *device_name_chksum = device_param->device_name_chksum;
13572 const u32 device_processors = device_param->device_processors;
13573 const u32 device_processor_cores = device_param->device_processor_cores;
13574
13575 /**
13576 * create context for each device
13577 */
13578
13579 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
13580
13581 /**
13582 * create command-queue
13583 */
13584
13585 // not supported with NV
13586 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13587
13588 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
13589
13590 /**
13591 * kernel threads: some algorithms need a fixed kernel-threads count
13592 * because of shared memory usage or bitslice
13593 * there needs to be some upper limit, otherwise there's too much overhead
13594 */
13595
13596 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
13597
13598 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
13599 {
13600 kernel_threads = KERNEL_THREADS_MAX_CPU;
13601 }
13602
13603 if (hash_mode == 1500) kernel_threads = 64; // DES
13604 if (hash_mode == 3000) kernel_threads = 64; // DES
13605 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
13606 if (hash_mode == 7500) kernel_threads = 64; // RC4
13607 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
13608 if (hash_mode == 9700) kernel_threads = 64; // RC4
13609 if (hash_mode == 9710) kernel_threads = 64; // RC4
13610 if (hash_mode == 9800) kernel_threads = 64; // RC4
13611 if (hash_mode == 9810) kernel_threads = 64; // RC4
13612 if (hash_mode == 10400) kernel_threads = 64; // RC4
13613 if (hash_mode == 10410) kernel_threads = 64; // RC4
13614 if (hash_mode == 10500) kernel_threads = 64; // RC4
13615 if (hash_mode == 13100) kernel_threads = 64; // RC4
13616
13617 /**
13618 * create input buffers on device : calculate size of fixed memory buffers
13619 */
13620
13621 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
13622 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13623
13624 device_param->size_root_css = size_root_css;
13625 device_param->size_markov_css = size_markov_css;
13626
13627 size_t size_results = kernel_threads * sizeof (uint);
13628
13629 device_param->size_results = size_results;
13630
13631 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13632 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13633
13634 size_t size_plains = digests_cnt * sizeof (plain_t);
13635 size_t size_salts = salts_cnt * sizeof (salt_t);
13636 size_t size_esalts = salts_cnt * esalt_size;
13637
13638 device_param->size_plains = size_plains;
13639 device_param->size_digests = size_digests;
13640 device_param->size_shown = size_shown;
13641 device_param->size_salts = size_salts;
13642
13643 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
13644 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
13645 size_t size_tm = 32 * sizeof (bs_word_t);
13646
13647 // scryptV stuff
13648
13649 size_t size_scryptV = 1;
13650
13651 if ((hash_mode == 8900) || (hash_mode == 9300))
13652 {
13653 uint tmto_start = 0;
13654 uint tmto_stop = 10;
13655
13656 if (scrypt_tmto)
13657 {
13658 tmto_start = scrypt_tmto;
13659 }
13660 else
13661 {
13662 // in case the user did not specify the tmto manually
13663 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13664 // but set the lower end only in case the user has a device with too less memory
13665
13666 if (hash_mode == 8900)
13667 {
13668 if (device_param->vendor_id == VENDOR_ID_AMD)
13669 {
13670 tmto_start = 1;
13671 }
13672 else if (device_param->vendor_id == VENDOR_ID_NV)
13673 {
13674 tmto_start = 2;
13675 }
13676 }
13677 else if (hash_mode == 9300)
13678 {
13679 if (device_param->vendor_id == VENDOR_ID_AMD)
13680 {
13681 tmto_start = 2;
13682 }
13683 else if (device_param->vendor_id == VENDOR_ID_NV)
13684 {
13685 tmto_start = 2;
13686 }
13687 }
13688 }
13689
13690 if (quiet == 0) log_info ("");
13691
13692 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13693 {
13694 // TODO: in theory the following calculation needs to be done per salt, not global
13695 // we assume all hashes have the same scrypt settings
13696
13697 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13698
13699 size_scryptV /= 1 << tmto;
13700
13701 size_scryptV *= device_processors * device_processor_cores;
13702
13703 if (size_scryptV > device_param->device_maxmem_alloc)
13704 {
13705 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13706
13707 continue;
13708 }
13709
13710 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13711 {
13712 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13713 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
13714 }
13715
13716 break;
13717 }
13718
13719 if (data.salts_buf[0].scrypt_phy == 0)
13720 {
13721 log_error ("ERROR: can't allocate enough device memory");
13722
13723 return -1;
13724 }
13725
13726 if (quiet == 0) log_info ("");
13727 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13728 }
13729
13730 /**
13731 * some algorithms need a fixed kernel-loops count
13732 */
13733
13734 if (hash_mode == 1500)
13735 {
13736 const u32 kernel_loops_fixed = 1024;
13737
13738 device_param->kernel_loops_min = kernel_loops_fixed;
13739 device_param->kernel_loops_max = kernel_loops_fixed;
13740 }
13741
13742 if (hash_mode == 3000)
13743 {
13744 const u32 kernel_loops_fixed = 1024;
13745
13746 device_param->kernel_loops_min = kernel_loops_fixed;
13747 device_param->kernel_loops_max = kernel_loops_fixed;
13748 }
13749
13750 if (hash_mode == 8900)
13751 {
13752 const u32 kernel_loops_fixed = 1;
13753
13754 device_param->kernel_loops_min = kernel_loops_fixed;
13755 device_param->kernel_loops_max = kernel_loops_fixed;
13756 }
13757
13758 if (hash_mode == 9300)
13759 {
13760 const u32 kernel_loops_fixed = 1;
13761
13762 device_param->kernel_loops_min = kernel_loops_fixed;
13763 device_param->kernel_loops_max = kernel_loops_fixed;
13764 }
13765
13766 if (hash_mode == 12500)
13767 {
13768 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
13769
13770 device_param->kernel_loops_min = kernel_loops_fixed;
13771 device_param->kernel_loops_max = kernel_loops_fixed;
13772 }
13773
13774 /**
13775 * some algorithms have a maximum kernel-loops count
13776 */
13777
13778 if (attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
13779 {
13780 if (data.salts_buf[0].salt_iter < device_param->kernel_loops_max)
13781 {
13782 device_param->kernel_loops_max = data.salts_buf[0].salt_iter;
13783 }
13784 }
13785
13786 /**
13787 * some algorithms need a special kernel-accel
13788 */
13789
13790 if (hash_mode == 8900)
13791 {
13792 device_param->kernel_accel_min = 1;
13793 device_param->kernel_accel_max = 64;
13794 }
13795
13796 if (hash_mode == 9300)
13797 {
13798 device_param->kernel_accel_min = 1;
13799 device_param->kernel_accel_max = 64;
13800 }
13801
13802 u32 kernel_accel_min = device_param->kernel_accel_min;
13803 u32 kernel_accel_max = device_param->kernel_accel_max;
13804
13805 // find out if we would request too much memory on memory blocks which are based on kernel_accel
13806
13807 size_t size_pws = 4;
13808 size_t size_tmps = 4;
13809 size_t size_hooks = 4;
13810
13811 while (kernel_accel_max >= kernel_accel_min)
13812 {
13813 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
13814
13815 // size_pws
13816
13817 size_pws = kernel_power_max * sizeof (pw_t);
13818
13819 // size_tmps
13820
13821 switch (hash_mode)
13822 {
13823 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
13824 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13825 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13826 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13827 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
13828 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
13829 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
13830 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
13831 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
13832 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
13833 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13834 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13835 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13836 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13837 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13838 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13839 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13840 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13841 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13842 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13843 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13844 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13845 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13846 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
13847 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
13848 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
13849 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
13850 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
13851 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13852 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13853 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
13854 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
13855 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13856 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
13857 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13858 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
13859 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
13860 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13861 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13862 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
13863 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
13864 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
13865 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13866 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
13867 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
13868 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
13869 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
13870 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13871 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
13872 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
13873 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
13874 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
13875 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13876 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
13877 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
13878 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
13879 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
13880 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
13881 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13882 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13883 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13884 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
13885 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
13886 };
13887
13888 // size_hooks
13889
13890 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13891 {
13892 // none yet
13893 }
13894
13895 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
13896 // if not, decrease amplifier and try again
13897
13898 int skip = 0;
13899
13900 if (size_pws > device_param->device_maxmem_alloc) skip = 1;
13901 if (size_tmps > device_param->device_maxmem_alloc) skip = 1;
13902 if (size_hooks > device_param->device_maxmem_alloc) skip = 1;
13903
13904 if (( bitmap_size
13905 + bitmap_size
13906 + bitmap_size
13907 + bitmap_size
13908 + bitmap_size
13909 + bitmap_size
13910 + bitmap_size
13911 + bitmap_size
13912 + size_bfs
13913 + size_combs
13914 + size_digests
13915 + size_esalts
13916 + size_hooks
13917 + size_markov_css
13918 + size_plains
13919 + size_pws
13920 + size_pws // not a bug
13921 + size_results
13922 + size_root_css
13923 + size_rules
13924 + size_rules_c
13925 + size_salts
13926 + size_scryptV
13927 + size_shown
13928 + size_tm
13929 + size_tmps) > device_param->device_global_mem) skip = 1;
13930
13931 if (skip == 1)
13932 {
13933 kernel_accel_max--;
13934
13935 continue;
13936 }
13937
13938 break;
13939 }
13940
13941 /*
13942 if (kernel_accel_max == 0)
13943 {
13944 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
13945
13946 return -1;
13947 }
13948 */
13949
13950 device_param->kernel_accel_min = kernel_accel_min;
13951 device_param->kernel_accel_max = kernel_accel_max;
13952
13953 /*
13954 if (kernel_accel_max < kernel_accel)
13955 {
13956 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
13957
13958 device_param->kernel_accel = kernel_accel_max;
13959 }
13960 */
13961
13962 device_param->size_bfs = size_bfs;
13963 device_param->size_combs = size_combs;
13964 device_param->size_rules = size_rules;
13965 device_param->size_rules_c = size_rules_c;
13966 device_param->size_pws = size_pws;
13967 device_param->size_tmps = size_tmps;
13968 device_param->size_hooks = size_hooks;
13969
13970 // do not confuse kernel_accel_max with kernel_accel here
13971
13972 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
13973
13974 device_param->kernel_threads = kernel_threads;
13975 device_param->kernel_power_user = kernel_power;
13976
13977 kernel_power_all += kernel_power;
13978
13979 /**
13980 * default building options
13981 */
13982
13983 char build_opts[1024] = { 0 };
13984
13985 // we don't have sm_* on vendors not NV but it doesn't matter
13986
13987 snprintf (build_opts, sizeof (build_opts) - 1, "-cl-std=CL1.1 -I\"%s/\" -DVENDOR_ID=%u -DCUDA_ARCH=%d -DVECT_SIZE=%u -DDEVICE_TYPE=%u -DKERN_TYPE=%u -D_unroll", shared_dir, device_param->vendor_id, (device_param->sm_major * 100) + device_param->sm_minor, device_param->vector_width, (u32) device_param->device_type, kern_type);
13988
13989 /**
13990 * main kernel
13991 */
13992
13993 {
13994 /**
13995 * kernel source filename
13996 */
13997
13998 char source_file[256] = { 0 };
13999
14000 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
14001
14002 struct stat sst;
14003
14004 if (stat (source_file, &sst) == -1)
14005 {
14006 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14007
14008 return -1;
14009 }
14010
14011 /**
14012 * kernel cached filename
14013 */
14014
14015 char cached_file[256] = { 0 };
14016
14017 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
14018
14019 int cached = 1;
14020
14021 struct stat cst;
14022
14023 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
14024 {
14025 cached = 0;
14026 }
14027
14028 /**
14029 * kernel compile or load
14030 */
14031
14032 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14033
14034 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14035
14036 if (force_jit_compilation == -1)
14037 {
14038 if (cached == 0)
14039 {
14040 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14041
14042 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14043
14044 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14045
14046 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
14047
14048 #ifdef DEBUG
14049 size_t build_log_size = 0;
14050
14051 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14052
14053 if (build_log_size > 1)
14054 {
14055 char *build_log = (char *) malloc (build_log_size + 1);
14056
14057 memset (build_log, 0, build_log_size + 1);
14058
14059 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14060
14061 puts (build_log);
14062
14063 free (build_log);
14064 }
14065 #endif
14066
14067 if (rc != 0)
14068 {
14069 device_param->skipped = true;
14070 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14071 continue;
14072 }
14073
14074 size_t binary_size;
14075
14076 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14077
14078 u8 *binary = (u8 *) mymalloc (binary_size);
14079
14080 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14081
14082 writeProgramBin (cached_file, binary, binary_size);
14083
14084 local_free (binary);
14085 }
14086 else
14087 {
14088 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14089
14090 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14091
14092 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14093
14094 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
14095 }
14096 }
14097 else
14098 {
14099 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
14100
14101 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14102
14103 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14104
14105 char build_opts_update[1024] = { 0 };
14106
14107 if (force_jit_compilation == 1500)
14108 {
14109 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
14110 }
14111 else if (force_jit_compilation == 8900)
14112 {
14113 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);
14114 }
14115 else
14116 {
14117 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
14118 }
14119
14120 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
14121
14122 #ifdef DEBUG
14123 size_t build_log_size = 0;
14124
14125 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14126
14127 if (build_log_size > 1)
14128 {
14129 char *build_log = (char *) malloc (build_log_size + 1);
14130
14131 memset (build_log, 0, build_log_size + 1);
14132
14133 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14134
14135 puts (build_log);
14136
14137 free (build_log);
14138 }
14139 #endif
14140
14141 if (rc != 0)
14142 {
14143 device_param->skipped = true;
14144
14145 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14146 }
14147 }
14148
14149 local_free (kernel_lengths);
14150 local_free (kernel_sources[0]);
14151 local_free (kernel_sources);
14152 }
14153
14154 /**
14155 * word generator kernel
14156 */
14157
14158 if (attack_mode != ATTACK_MODE_STRAIGHT)
14159 {
14160 /**
14161 * kernel mp source filename
14162 */
14163
14164 char source_file[256] = { 0 };
14165
14166 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
14167
14168 struct stat sst;
14169
14170 if (stat (source_file, &sst) == -1)
14171 {
14172 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14173
14174 return -1;
14175 }
14176
14177 /**
14178 * kernel mp cached filename
14179 */
14180
14181 char cached_file[256] = { 0 };
14182
14183 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
14184
14185 int cached = 1;
14186
14187 struct stat cst;
14188
14189 if (stat (cached_file, &cst) == -1)
14190 {
14191 cached = 0;
14192 }
14193
14194 /**
14195 * kernel compile or load
14196 */
14197
14198 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14199
14200 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14201
14202 if (cached == 0)
14203 {
14204 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14205
14206 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14207
14208 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14209
14210 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
14211
14212 if (rc != 0)
14213 {
14214 device_param->skipped = true;
14215 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14216 continue;
14217 }
14218
14219 size_t binary_size;
14220
14221 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14222
14223 u8 *binary = (u8 *) mymalloc (binary_size);
14224
14225 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14226
14227 writeProgramBin (cached_file, binary, binary_size);
14228
14229 local_free (binary);
14230 }
14231 else
14232 {
14233 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14234
14235 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14236
14237 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14238
14239 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
14240 }
14241
14242 local_free (kernel_lengths);
14243 local_free (kernel_sources[0]);
14244 local_free (kernel_sources);
14245 }
14246
14247 /**
14248 * amplifier kernel
14249 */
14250
14251 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14252 {
14253
14254 }
14255 else
14256 {
14257 /**
14258 * kernel amp source filename
14259 */
14260
14261 char source_file[256] = { 0 };
14262
14263 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
14264
14265 struct stat sst;
14266
14267 if (stat (source_file, &sst) == -1)
14268 {
14269 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14270
14271 return -1;
14272 }
14273
14274 /**
14275 * kernel amp cached filename
14276 */
14277
14278 char cached_file[256] = { 0 };
14279
14280 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
14281
14282 int cached = 1;
14283
14284 struct stat cst;
14285
14286 if (stat (cached_file, &cst) == -1)
14287 {
14288 cached = 0;
14289 }
14290
14291 /**
14292 * kernel compile or load
14293 */
14294
14295 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14296
14297 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14298
14299 if (cached == 0)
14300 {
14301 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14302
14303 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14304
14305 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14306
14307 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
14308
14309 if (rc != 0)
14310 {
14311 device_param->skipped = true;
14312 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14313 continue;
14314 }
14315
14316 size_t binary_size;
14317
14318 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14319
14320 u8 *binary = (u8 *) mymalloc (binary_size);
14321
14322 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14323
14324 writeProgramBin (cached_file, binary, binary_size);
14325
14326 local_free (binary);
14327 }
14328 else
14329 {
14330 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14331
14332 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14333
14334 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14335
14336 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
14337 }
14338
14339 local_free (kernel_lengths);
14340 local_free (kernel_sources[0]);
14341 local_free (kernel_sources);
14342 }
14343
14344 // some algorithm collide too fast, make that impossible
14345
14346 if (benchmark == 1)
14347 {
14348 ((uint *) digests_buf)[0] = -1;
14349 ((uint *) digests_buf)[1] = -1;
14350 ((uint *) digests_buf)[2] = -1;
14351 ((uint *) digests_buf)[3] = -1;
14352 }
14353
14354 /**
14355 * global buffers
14356 */
14357
14358 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14359 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14360 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
14361 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
14362 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14363 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14364 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14365 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14366 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14367 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14368 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14369 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14370 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
14371 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
14372 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
14373 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
14374 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
14375 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
14376
14377 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);
14378 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);
14379 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);
14380 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);
14381 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);
14382 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);
14383 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);
14384 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);
14385 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
14386 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
14387 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
14388
14389 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
14390 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
14391 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
14392 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
14393 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
14394 run_kernel_bzero (device_param, device_param->d_result, size_results);
14395
14396 /**
14397 * special buffers
14398 */
14399
14400 if (attack_kern == ATTACK_KERN_STRAIGHT)
14401 {
14402 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
14403 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
14404
14405 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
14406
14407 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
14408 }
14409 else if (attack_kern == ATTACK_KERN_COMBI)
14410 {
14411 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14412 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14413 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14414 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14415
14416 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
14417 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
14418 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14419 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14420 }
14421 else if (attack_kern == ATTACK_KERN_BF)
14422 {
14423 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14424 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14425 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
14426 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14427 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14428
14429 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
14430 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
14431 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
14432 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14433 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14434 }
14435
14436 if (size_esalts)
14437 {
14438 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
14439
14440 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
14441 }
14442
14443 /**
14444 * main host data
14445 */
14446
14447 uint *result = (uint *) mymalloc (size_results);
14448
14449 device_param->result = result;
14450
14451 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
14452
14453 device_param->pws_buf = pws_buf;
14454
14455 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
14456
14457 device_param->combs_buf = combs_buf;
14458
14459 void *hooks_buf = mymalloc (size_hooks);
14460
14461 device_param->hooks_buf = hooks_buf;
14462
14463 /**
14464 * kernel args
14465 */
14466
14467 device_param->kernel_params_buf32[21] = bitmap_mask;
14468 device_param->kernel_params_buf32[22] = bitmap_shift1;
14469 device_param->kernel_params_buf32[23] = bitmap_shift2;
14470 device_param->kernel_params_buf32[24] = 0; // salt_pos
14471 device_param->kernel_params_buf32[25] = 0; // loop_pos
14472 device_param->kernel_params_buf32[26] = 0; // loop_cnt
14473 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
14474 device_param->kernel_params_buf32[28] = 0; // digests_cnt
14475 device_param->kernel_params_buf32[29] = 0; // digests_offset
14476 device_param->kernel_params_buf32[30] = 0; // combs_mode
14477 device_param->kernel_params_buf32[31] = 0; // gid_max
14478
14479 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14480 ? &device_param->d_pws_buf
14481 : &device_param->d_pws_amp_buf;
14482 device_param->kernel_params[ 1] = &device_param->d_rules_c;
14483 device_param->kernel_params[ 2] = &device_param->d_combs_c;
14484 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
14485 device_param->kernel_params[ 4] = &device_param->d_tmps;
14486 device_param->kernel_params[ 5] = &device_param->d_hooks;
14487 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
14488 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
14489 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
14490 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
14491 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
14492 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
14493 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
14494 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
14495 device_param->kernel_params[14] = &device_param->d_plain_bufs;
14496 device_param->kernel_params[15] = &device_param->d_digests_buf;
14497 device_param->kernel_params[16] = &device_param->d_digests_shown;
14498 device_param->kernel_params[17] = &device_param->d_salt_bufs;
14499 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
14500 device_param->kernel_params[19] = &device_param->d_result;
14501 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
14502 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
14503 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
14504 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
14505 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
14506 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
14507 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
14508 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
14509 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
14510 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
14511 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
14512 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
14513
14514 device_param->kernel_params_mp_buf64[3] = 0;
14515 device_param->kernel_params_mp_buf32[4] = 0;
14516 device_param->kernel_params_mp_buf32[5] = 0;
14517 device_param->kernel_params_mp_buf32[6] = 0;
14518 device_param->kernel_params_mp_buf32[7] = 0;
14519 device_param->kernel_params_mp_buf32[8] = 0;
14520
14521 device_param->kernel_params_mp[0] = NULL;
14522 device_param->kernel_params_mp[1] = NULL;
14523 device_param->kernel_params_mp[2] = NULL;
14524 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
14525 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
14526 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
14527 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
14528 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
14529 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
14530
14531 device_param->kernel_params_mp_l_buf64[3] = 0;
14532 device_param->kernel_params_mp_l_buf32[4] = 0;
14533 device_param->kernel_params_mp_l_buf32[5] = 0;
14534 device_param->kernel_params_mp_l_buf32[6] = 0;
14535 device_param->kernel_params_mp_l_buf32[7] = 0;
14536 device_param->kernel_params_mp_l_buf32[8] = 0;
14537 device_param->kernel_params_mp_l_buf32[9] = 0;
14538
14539 device_param->kernel_params_mp_l[0] = NULL;
14540 device_param->kernel_params_mp_l[1] = NULL;
14541 device_param->kernel_params_mp_l[2] = NULL;
14542 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14543 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14544 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14545 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14546 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14547 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14548 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14549
14550 device_param->kernel_params_mp_r_buf64[3] = 0;
14551 device_param->kernel_params_mp_r_buf32[4] = 0;
14552 device_param->kernel_params_mp_r_buf32[5] = 0;
14553 device_param->kernel_params_mp_r_buf32[6] = 0;
14554 device_param->kernel_params_mp_r_buf32[7] = 0;
14555 device_param->kernel_params_mp_r_buf32[8] = 0;
14556
14557 device_param->kernel_params_mp_r[0] = NULL;
14558 device_param->kernel_params_mp_r[1] = NULL;
14559 device_param->kernel_params_mp_r[2] = NULL;
14560 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14561 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14562 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14563 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14564 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14565 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14566
14567 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14568 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14569
14570 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14571 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14572 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14573 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14574 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14575 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14576 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14577
14578 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14579 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14580
14581 /**
14582 * kernel name
14583 */
14584
14585 char kernel_name[64] = { 0 };
14586
14587 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14588 {
14589 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14590 {
14591 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14592
14593 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14594
14595 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14596
14597 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14598
14599 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14600
14601 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14602 }
14603 else
14604 {
14605 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14606
14607 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14608
14609 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14610
14611 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14612
14613 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14614
14615 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14616 }
14617
14618 if (data.attack_mode == ATTACK_MODE_BF)
14619 {
14620 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14621 {
14622 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14623
14624 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14625 }
14626 }
14627 }
14628 else
14629 {
14630 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14631
14632 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14633
14634 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14635
14636 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14637
14638 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14639
14640 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14641
14642 if (opts_type & OPTS_TYPE_HOOK12)
14643 {
14644 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14645
14646 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14647 }
14648
14649 if (opts_type & OPTS_TYPE_HOOK23)
14650 {
14651 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14652
14653 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14654 }
14655 }
14656
14657 for (uint i = 0; i <= 20; i++)
14658 {
14659 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14660 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14661 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14662
14663 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14664 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14665 }
14666
14667 for (uint i = 21; i <= 31; i++)
14668 {
14669 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14670 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14671 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14672
14673 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14674 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14675 }
14676
14677 if (attack_mode == ATTACK_MODE_BF)
14678 {
14679 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
14680 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
14681
14682 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14683 {
14684 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14685 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14686 }
14687 }
14688 else if (attack_mode == ATTACK_MODE_HYBRID1)
14689 {
14690 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14691 }
14692 else if (attack_mode == ATTACK_MODE_HYBRID2)
14693 {
14694 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14695 }
14696
14697 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14698 {
14699 // nothing to do
14700 }
14701 else
14702 {
14703 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
14704 }
14705
14706 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14707 {
14708 // nothing to do
14709 }
14710 else
14711 {
14712 for (uint i = 0; i < 5; i++)
14713 {
14714 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14715 }
14716
14717 for (uint i = 5; i < 7; i++)
14718 {
14719 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14720 }
14721 }
14722
14723 /**
14724 * Store initial fanspeed if gpu_temp_retain is enabled
14725 */
14726
14727 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
14728 int gpu_temp_retain_set = 0;
14729
14730 if (gpu_temp_disable == 0)
14731 {
14732 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14733 {
14734 hc_thread_mutex_lock (mux_adl);
14735
14736 if (data.hm_device[device_id].fan_supported == 1)
14737 {
14738 if (gpu_temp_retain_chgd == 0)
14739 {
14740 uint cur_temp = 0;
14741 uint default_temp = 0;
14742
14743 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);
14744
14745 if (ADL_rc == ADL_OK)
14746 {
14747 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14748
14749 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14750
14751 // special case with multi gpu setups: always use minimum retain
14752
14753 if (gpu_temp_retain_set == 0)
14754 {
14755 gpu_temp_retain = gpu_temp_retain_target;
14756 gpu_temp_retain_set = 1;
14757 }
14758 else
14759 {
14760 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14761 }
14762
14763 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14764 }
14765 }
14766
14767 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14768
14769 temp_retain_fanspeed_value[device_id] = fan_speed;
14770
14771 if (fan_speed == -1)
14772 {
14773 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14774
14775 temp_retain_fanspeed_value[device_id] = 0;
14776 }
14777 }
14778
14779 hc_thread_mutex_unlock (mux_adl);
14780 }
14781 }
14782
14783 /**
14784 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14785 */
14786
14787 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14788 {
14789 hc_thread_mutex_lock (mux_adl);
14790
14791 if (data.hm_device[device_id].od_version == 6)
14792 {
14793 int ADL_rc;
14794
14795 // check powertune capabilities first, if not available then skip device
14796
14797 int powertune_supported = 0;
14798
14799 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14800 {
14801 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14802
14803 return (-1);
14804 }
14805
14806 if (powertune_supported != 0)
14807 {
14808 // powercontrol settings
14809
14810 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14811
14812 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14813 {
14814 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14815 }
14816
14817 if (ADL_rc != ADL_OK)
14818 {
14819 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14820
14821 return (-1);
14822 }
14823
14824 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14825 {
14826 log_error ("ERROR: Failed to set new ADL PowerControl values");
14827
14828 return (-1);
14829 }
14830
14831 // clocks
14832
14833 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14834
14835 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14836
14837 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)
14838 {
14839 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14840
14841 return (-1);
14842 }
14843
14844 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14845
14846 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14847
14848 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14849 {
14850 log_error ("ERROR: Failed to get ADL device capabilities");
14851
14852 return (-1);
14853 }
14854
14855 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14856 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14857
14858 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14859 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14860
14861 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14862 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14863
14864 // warning if profile has too low max values
14865
14866 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14867 {
14868 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14869 }
14870
14871 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14872 {
14873 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14874 }
14875
14876 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14877
14878 performance_state->iNumberOfPerformanceLevels = 2;
14879
14880 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14881 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14882 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14883 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14884
14885 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)
14886 {
14887 log_info ("ERROR: Failed to set ADL performance state");
14888
14889 return (-1);
14890 }
14891
14892 local_free (performance_state);
14893 }
14894 }
14895
14896 hc_thread_mutex_unlock (mux_adl);
14897 }
14898 #endif // HAVE_HWMON && HAVE_ADL
14899 }
14900
14901 data.kernel_power_all = kernel_power_all;
14902
14903 if (data.quiet == 0) log_info ("");
14904
14905 /**
14906 * In benchmark-mode, inform user which algorithm is checked
14907 */
14908
14909 if (benchmark == 1)
14910 {
14911 quiet = 0;
14912
14913 data.quiet = quiet;
14914
14915 char *hash_type = strhashtype (data.hash_mode); // not a bug
14916
14917 log_info ("Hashtype: %s", hash_type);
14918 log_info ("");
14919 }
14920
14921 /**
14922 * keep track of the progress
14923 */
14924
14925 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14926 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14927 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14928
14929 /**
14930 * open filehandles
14931 */
14932
14933 #if _WIN
14934 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14935 {
14936 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14937
14938 return (-1);
14939 }
14940
14941 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14942 {
14943 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14944
14945 return (-1);
14946 }
14947
14948 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14949 {
14950 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14951
14952 return (-1);
14953 }
14954 #endif
14955
14956 /**
14957 * dictionary pad
14958 */
14959
14960 segment_size *= (1024 * 1024);
14961
14962 data.segment_size = segment_size;
14963
14964 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14965
14966 wl_data->buf = (char *) mymalloc (segment_size);
14967 wl_data->avail = segment_size;
14968 wl_data->incr = segment_size;
14969 wl_data->cnt = 0;
14970 wl_data->pos = 0;
14971
14972 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14973
14974 data.wordlist_mode = wordlist_mode;
14975
14976 cs_t *css_buf = NULL;
14977 uint css_cnt = 0;
14978 uint dictcnt = 0;
14979 uint maskcnt = 1;
14980 char **masks = NULL;
14981 char **dictfiles = NULL;
14982
14983 uint mask_from_file = 0;
14984
14985 if (attack_mode == ATTACK_MODE_STRAIGHT)
14986 {
14987 if (wordlist_mode == WL_MODE_FILE)
14988 {
14989 int wls_left = myargc - (optind + 1);
14990
14991 for (int i = 0; i < wls_left; i++)
14992 {
14993 char *l0_filename = myargv[optind + 1 + i];
14994
14995 struct stat l0_stat;
14996
14997 if (stat (l0_filename, &l0_stat) == -1)
14998 {
14999 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
15000
15001 return (-1);
15002 }
15003
15004 uint is_dir = S_ISDIR (l0_stat.st_mode);
15005
15006 if (is_dir == 0)
15007 {
15008 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15009
15010 dictcnt++;
15011
15012 dictfiles[dictcnt - 1] = l0_filename;
15013 }
15014 else
15015 {
15016 // do not allow --keyspace w/ a directory
15017
15018 if (keyspace == 1)
15019 {
15020 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15021
15022 return (-1);
15023 }
15024
15025 char **dictionary_files = NULL;
15026
15027 dictionary_files = scan_directory (l0_filename);
15028
15029 if (dictionary_files != NULL)
15030 {
15031 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15032
15033 for (int d = 0; dictionary_files[d] != NULL; d++)
15034 {
15035 char *l1_filename = dictionary_files[d];
15036
15037 struct stat l1_stat;
15038
15039 if (stat (l1_filename, &l1_stat) == -1)
15040 {
15041 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15042
15043 return (-1);
15044 }
15045
15046 if (S_ISREG (l1_stat.st_mode))
15047 {
15048 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15049
15050 dictcnt++;
15051
15052 dictfiles[dictcnt - 1] = strdup (l1_filename);
15053 }
15054 }
15055 }
15056
15057 local_free (dictionary_files);
15058 }
15059 }
15060
15061 if (dictcnt < 1)
15062 {
15063 log_error ("ERROR: No usable dictionary file found.");
15064
15065 return (-1);
15066 }
15067 }
15068 else if (wordlist_mode == WL_MODE_STDIN)
15069 {
15070 dictcnt = 1;
15071 }
15072 }
15073 else if (attack_mode == ATTACK_MODE_COMBI)
15074 {
15075 // display
15076
15077 char *dictfile1 = myargv[optind + 1 + 0];
15078 char *dictfile2 = myargv[optind + 1 + 1];
15079
15080 // find the bigger dictionary and use as base
15081
15082 FILE *fp1 = NULL;
15083 FILE *fp2 = NULL;
15084
15085 struct stat tmp_stat;
15086
15087 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
15088 {
15089 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15090
15091 return (-1);
15092 }
15093
15094 if (stat (dictfile1, &tmp_stat) == -1)
15095 {
15096 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15097
15098 fclose (fp1);
15099
15100 return (-1);
15101 }
15102
15103 if (S_ISDIR (tmp_stat.st_mode))
15104 {
15105 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
15106
15107 fclose (fp1);
15108
15109 return (-1);
15110 }
15111
15112 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
15113 {
15114 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15115
15116 fclose (fp1);
15117
15118 return (-1);
15119 }
15120
15121 if (stat (dictfile2, &tmp_stat) == -1)
15122 {
15123 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15124
15125 fclose (fp1);
15126 fclose (fp2);
15127
15128 return (-1);
15129 }
15130
15131 if (S_ISDIR (tmp_stat.st_mode))
15132 {
15133 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
15134
15135 fclose (fp1);
15136 fclose (fp2);
15137
15138 return (-1);
15139 }
15140
15141 data.combs_cnt = 1;
15142
15143 data.quiet = 1;
15144
15145 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
15146
15147 data.quiet = quiet;
15148
15149 if (words1_cnt == 0)
15150 {
15151 log_error ("ERROR: %s: empty file", dictfile1);
15152
15153 fclose (fp1);
15154 fclose (fp2);
15155
15156 return (-1);
15157 }
15158
15159 data.combs_cnt = 1;
15160
15161 data.quiet = 1;
15162
15163 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
15164
15165 data.quiet = quiet;
15166
15167 if (words2_cnt == 0)
15168 {
15169 log_error ("ERROR: %s: empty file", dictfile2);
15170
15171 fclose (fp1);
15172 fclose (fp2);
15173
15174 return (-1);
15175 }
15176
15177 fclose (fp1);
15178 fclose (fp2);
15179
15180 data.dictfile = dictfile1;
15181 data.dictfile2 = dictfile2;
15182
15183 if (words1_cnt >= words2_cnt)
15184 {
15185 data.combs_cnt = words2_cnt;
15186 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15187
15188 dictfiles = &data.dictfile;
15189
15190 dictcnt = 1;
15191 }
15192 else
15193 {
15194 data.combs_cnt = words1_cnt;
15195 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15196
15197 dictfiles = &data.dictfile2;
15198
15199 dictcnt = 1;
15200
15201 // we also have to switch wordlist related rules!
15202
15203 char *tmpc = data.rule_buf_l;
15204
15205 data.rule_buf_l = data.rule_buf_r;
15206 data.rule_buf_r = tmpc;
15207
15208 int tmpi = data.rule_len_l;
15209
15210 data.rule_len_l = data.rule_len_r;
15211 data.rule_len_r = tmpi;
15212 }
15213 }
15214 else if (attack_mode == ATTACK_MODE_BF)
15215 {
15216 char *mask = NULL;
15217
15218 maskcnt = 0;
15219
15220 if (benchmark == 0)
15221 {
15222 mask = myargv[optind + 1];
15223
15224 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
15225
15226 if ((optind + 2) <= myargc)
15227 {
15228 struct stat file_stat;
15229
15230 if (stat (mask, &file_stat) == -1)
15231 {
15232 maskcnt = 1;
15233
15234 masks[maskcnt - 1] = mystrdup (mask);
15235 }
15236 else
15237 {
15238 int wls_left = myargc - (optind + 1);
15239
15240 uint masks_avail = INCR_MASKS;
15241
15242 for (int i = 0; i < wls_left; i++)
15243 {
15244 if (i != 0)
15245 {
15246 mask = myargv[optind + 1 + i];
15247
15248 if (stat (mask, &file_stat) == -1)
15249 {
15250 log_error ("ERROR: %s: %s", mask, strerror (errno));
15251
15252 return (-1);
15253 }
15254 }
15255
15256 uint is_file = S_ISREG (file_stat.st_mode);
15257
15258 if (is_file == 1)
15259 {
15260 FILE *mask_fp;
15261
15262 if ((mask_fp = fopen (mask, "r")) == NULL)
15263 {
15264 log_error ("ERROR: %s: %s", mask, strerror (errno));
15265
15266 return (-1);
15267 }
15268
15269 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15270
15271 while (!feof (mask_fp))
15272 {
15273 memset (line_buf, 0, HCBUFSIZ);
15274
15275 int line_len = fgetl (mask_fp, line_buf);
15276
15277 if (line_len == 0) continue;
15278
15279 if (line_buf[0] == '#') continue;
15280
15281 if (masks_avail == maskcnt)
15282 {
15283 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15284
15285 masks_avail += INCR_MASKS;
15286 }
15287
15288 masks[maskcnt] = mystrdup (line_buf);
15289
15290 maskcnt++;
15291 }
15292
15293 myfree (line_buf);
15294
15295 fclose (mask_fp);
15296 }
15297 else
15298 {
15299 log_error ("ERROR: %s: unsupported file-type", mask);
15300
15301 return (-1);
15302 }
15303 }
15304
15305 mask_from_file = 1;
15306 }
15307 }
15308 else
15309 {
15310 custom_charset_1 = (char *) "?l?d?u";
15311 custom_charset_2 = (char *) "?l?d";
15312 custom_charset_3 = (char *) "?l?d*!$@_";
15313
15314 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15315 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15316 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15317
15318 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
15319
15320 wordlist_mode = WL_MODE_MASK;
15321
15322 data.wordlist_mode = wordlist_mode;
15323
15324 increment = 1;
15325
15326 maskcnt = 1;
15327 }
15328 }
15329 else
15330 {
15331 /**
15332 * generate full masks and charsets
15333 */
15334
15335 masks = (char **) mymalloc (sizeof (char *));
15336
15337 switch (hash_mode)
15338 {
15339 case 1731: pw_min = 5;
15340 pw_max = 5;
15341 mask = mystrdup ("?b?b?b?b?b");
15342 break;
15343 case 12500: pw_min = 5;
15344 pw_max = 5;
15345 mask = mystrdup ("?b?b?b?b?b");
15346 break;
15347 default: pw_min = 7;
15348 pw_max = 7;
15349 mask = mystrdup ("?b?b?b?b?b?b?b");
15350 break;
15351 }
15352
15353 maskcnt = 1;
15354
15355 masks[maskcnt - 1] = mystrdup (mask);
15356
15357 wordlist_mode = WL_MODE_MASK;
15358
15359 data.wordlist_mode = wordlist_mode;
15360
15361 increment = 1;
15362 }
15363
15364 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
15365
15366 if (increment)
15367 {
15368 if (increment_min > pw_min) pw_min = increment_min;
15369
15370 if (increment_max < pw_max) pw_max = increment_max;
15371 }
15372 }
15373 else if (attack_mode == ATTACK_MODE_HYBRID1)
15374 {
15375 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15376
15377 // display
15378
15379 char *mask = myargv[myargc - 1];
15380
15381 maskcnt = 0;
15382
15383 masks = (char **) mymalloc (1 * sizeof (char *));
15384
15385 // mod
15386
15387 struct stat file_stat;
15388
15389 if (stat (mask, &file_stat) == -1)
15390 {
15391 maskcnt = 1;
15392
15393 masks[maskcnt - 1] = mystrdup (mask);
15394 }
15395 else
15396 {
15397 uint is_file = S_ISREG (file_stat.st_mode);
15398
15399 if (is_file == 1)
15400 {
15401 FILE *mask_fp;
15402
15403 if ((mask_fp = fopen (mask, "r")) == NULL)
15404 {
15405 log_error ("ERROR: %s: %s", mask, strerror (errno));
15406
15407 return (-1);
15408 }
15409
15410 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15411
15412 uint masks_avail = 1;
15413
15414 while (!feof (mask_fp))
15415 {
15416 memset (line_buf, 0, HCBUFSIZ);
15417
15418 int line_len = fgetl (mask_fp, line_buf);
15419
15420 if (line_len == 0) continue;
15421
15422 if (line_buf[0] == '#') continue;
15423
15424 if (masks_avail == maskcnt)
15425 {
15426 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15427
15428 masks_avail += INCR_MASKS;
15429 }
15430
15431 masks[maskcnt] = mystrdup (line_buf);
15432
15433 maskcnt++;
15434 }
15435
15436 myfree (line_buf);
15437
15438 fclose (mask_fp);
15439
15440 mask_from_file = 1;
15441 }
15442 else
15443 {
15444 maskcnt = 1;
15445
15446 masks[maskcnt - 1] = mystrdup (mask);
15447 }
15448 }
15449
15450 // base
15451
15452 int wls_left = myargc - (optind + 2);
15453
15454 for (int i = 0; i < wls_left; i++)
15455 {
15456 char *filename = myargv[optind + 1 + i];
15457
15458 struct stat file_stat;
15459
15460 if (stat (filename, &file_stat) == -1)
15461 {
15462 log_error ("ERROR: %s: %s", filename, strerror (errno));
15463
15464 return (-1);
15465 }
15466
15467 uint is_dir = S_ISDIR (file_stat.st_mode);
15468
15469 if (is_dir == 0)
15470 {
15471 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15472
15473 dictcnt++;
15474
15475 dictfiles[dictcnt - 1] = filename;
15476 }
15477 else
15478 {
15479 // do not allow --keyspace w/ a directory
15480
15481 if (keyspace == 1)
15482 {
15483 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15484
15485 return (-1);
15486 }
15487
15488 char **dictionary_files = NULL;
15489
15490 dictionary_files = scan_directory (filename);
15491
15492 if (dictionary_files != NULL)
15493 {
15494 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15495
15496 for (int d = 0; dictionary_files[d] != NULL; d++)
15497 {
15498 char *l1_filename = dictionary_files[d];
15499
15500 struct stat l1_stat;
15501
15502 if (stat (l1_filename, &l1_stat) == -1)
15503 {
15504 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15505
15506 return (-1);
15507 }
15508
15509 if (S_ISREG (l1_stat.st_mode))
15510 {
15511 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15512
15513 dictcnt++;
15514
15515 dictfiles[dictcnt - 1] = strdup (l1_filename);
15516 }
15517 }
15518 }
15519
15520 local_free (dictionary_files);
15521 }
15522 }
15523
15524 if (dictcnt < 1)
15525 {
15526 log_error ("ERROR: No usable dictionary file found.");
15527
15528 return (-1);
15529 }
15530
15531 if (increment)
15532 {
15533 maskcnt = 0;
15534
15535 uint mask_min = increment_min; // we can't reject smaller masks here
15536 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15537
15538 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15539 {
15540 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15541
15542 if (cur_mask == NULL) break;
15543
15544 masks[maskcnt] = cur_mask;
15545
15546 maskcnt++;
15547
15548 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15549 }
15550 }
15551 }
15552 else if (attack_mode == ATTACK_MODE_HYBRID2)
15553 {
15554 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15555
15556 // display
15557
15558 char *mask = myargv[optind + 1 + 0];
15559
15560 maskcnt = 0;
15561
15562 masks = (char **) mymalloc (1 * sizeof (char *));
15563
15564 // mod
15565
15566 struct stat file_stat;
15567
15568 if (stat (mask, &file_stat) == -1)
15569 {
15570 maskcnt = 1;
15571
15572 masks[maskcnt - 1] = mystrdup (mask);
15573 }
15574 else
15575 {
15576 uint is_file = S_ISREG (file_stat.st_mode);
15577
15578 if (is_file == 1)
15579 {
15580 FILE *mask_fp;
15581
15582 if ((mask_fp = fopen (mask, "r")) == NULL)
15583 {
15584 log_error ("ERROR: %s: %s", mask, strerror (errno));
15585
15586 return (-1);
15587 }
15588
15589 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15590
15591 uint masks_avail = 1;
15592
15593 while (!feof (mask_fp))
15594 {
15595 memset (line_buf, 0, HCBUFSIZ);
15596
15597 int line_len = fgetl (mask_fp, line_buf);
15598
15599 if (line_len == 0) continue;
15600
15601 if (line_buf[0] == '#') continue;
15602
15603 if (masks_avail == maskcnt)
15604 {
15605 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15606
15607 masks_avail += INCR_MASKS;
15608 }
15609
15610 masks[maskcnt] = mystrdup (line_buf);
15611
15612 maskcnt++;
15613 }
15614
15615 myfree (line_buf);
15616
15617 fclose (mask_fp);
15618
15619 mask_from_file = 1;
15620 }
15621 else
15622 {
15623 maskcnt = 1;
15624
15625 masks[maskcnt - 1] = mystrdup (mask);
15626 }
15627 }
15628
15629 // base
15630
15631 int wls_left = myargc - (optind + 2);
15632
15633 for (int i = 0; i < wls_left; i++)
15634 {
15635 char *filename = myargv[optind + 2 + i];
15636
15637 struct stat file_stat;
15638
15639 if (stat (filename, &file_stat) == -1)
15640 {
15641 log_error ("ERROR: %s: %s", filename, strerror (errno));
15642
15643 return (-1);
15644 }
15645
15646 uint is_dir = S_ISDIR (file_stat.st_mode);
15647
15648 if (is_dir == 0)
15649 {
15650 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15651
15652 dictcnt++;
15653
15654 dictfiles[dictcnt - 1] = filename;
15655 }
15656 else
15657 {
15658 // do not allow --keyspace w/ a directory
15659
15660 if (keyspace == 1)
15661 {
15662 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15663
15664 return (-1);
15665 }
15666
15667 char **dictionary_files = NULL;
15668
15669 dictionary_files = scan_directory (filename);
15670
15671 if (dictionary_files != NULL)
15672 {
15673 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15674
15675 for (int d = 0; dictionary_files[d] != NULL; d++)
15676 {
15677 char *l1_filename = dictionary_files[d];
15678
15679 struct stat l1_stat;
15680
15681 if (stat (l1_filename, &l1_stat) == -1)
15682 {
15683 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15684
15685 return (-1);
15686 }
15687
15688 if (S_ISREG (l1_stat.st_mode))
15689 {
15690 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15691
15692 dictcnt++;
15693
15694 dictfiles[dictcnt - 1] = strdup (l1_filename);
15695 }
15696 }
15697 }
15698
15699 local_free (dictionary_files);
15700 }
15701 }
15702
15703 if (dictcnt < 1)
15704 {
15705 log_error ("ERROR: No usable dictionary file found.");
15706
15707 return (-1);
15708 }
15709
15710 if (increment)
15711 {
15712 maskcnt = 0;
15713
15714 uint mask_min = increment_min; // we can't reject smaller masks here
15715 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15716
15717 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15718 {
15719 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15720
15721 if (cur_mask == NULL) break;
15722
15723 masks[maskcnt] = cur_mask;
15724
15725 maskcnt++;
15726
15727 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15728 }
15729 }
15730 }
15731
15732 data.pw_min = pw_min;
15733 data.pw_max = pw_max;
15734
15735 /**
15736 * weak hash check
15737 */
15738
15739 if (weak_hash_threshold >= salts_cnt)
15740 {
15741 hc_device_param_t *device_param = NULL;
15742
15743 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15744 {
15745 device_param = &data.devices_param[device_id];
15746
15747 if (device_param->skipped) continue;
15748
15749 break;
15750 }
15751
15752 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15753
15754 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15755 {
15756 weak_hash_check (device_param, salt_pos);
15757 }
15758 }
15759
15760 // Display hack, guarantee that there is at least one \r before real start
15761
15762 if (data.quiet == 0) log_info_nn ("");
15763
15764 /**
15765 * status and monitor threads
15766 */
15767
15768 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15769
15770 hc_thread_t i_thread = 0;
15771
15772 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15773 {
15774 hc_thread_create (i_thread, thread_keypress, &benchmark);
15775 }
15776
15777 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15778
15779 uint ni_threads_cnt = 0;
15780
15781 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15782
15783 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15784
15785 ni_threads_cnt++;
15786
15787 /**
15788 * Outfile remove
15789 */
15790
15791 if (keyspace == 0)
15792 {
15793 if (outfile_check_timer != 0)
15794 {
15795 if (data.outfile_check_directory != NULL)
15796 {
15797 if ((hash_mode != 5200) &&
15798 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15799 (hash_mode != 9000))
15800 {
15801 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15802
15803 ni_threads_cnt++;
15804 }
15805 else
15806 {
15807 outfile_check_timer = 0;
15808 }
15809 }
15810 else
15811 {
15812 outfile_check_timer = 0;
15813 }
15814 }
15815 }
15816
15817 /**
15818 * Inform the user if we got some hashes remove because of the pot file remove feature
15819 */
15820
15821 if (data.quiet == 0)
15822 {
15823 if (potfile_remove_cracks > 0)
15824 {
15825 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15826 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15827 }
15828 }
15829
15830 data.outfile_check_timer = outfile_check_timer;
15831
15832 /**
15833 * main loop
15834 */
15835
15836 char **induction_dictionaries = NULL;
15837
15838 int induction_dictionaries_cnt = 0;
15839
15840 hcstat_table_t *root_table_buf = NULL;
15841 hcstat_table_t *markov_table_buf = NULL;
15842
15843 uint initial_restore_done = 0;
15844
15845 data.maskcnt = maskcnt;
15846
15847 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15848 {
15849 if (data.devices_status == STATUS_CRACKED) break;
15850
15851 data.devices_status = STATUS_INIT;
15852
15853 if (maskpos > rd->maskpos)
15854 {
15855 rd->dictpos = 0;
15856 }
15857
15858 rd->maskpos = maskpos;
15859 data.maskpos = maskpos;
15860
15861 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15862 {
15863 char *mask = masks[maskpos];
15864
15865 if (mask_from_file == 1)
15866 {
15867 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15868
15869 char *str_ptr;
15870 uint str_pos;
15871
15872 uint mask_offset = 0;
15873
15874 uint separator_cnt;
15875
15876 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15877 {
15878 str_ptr = strstr (mask + mask_offset, ",");
15879
15880 if (str_ptr == NULL) break;
15881
15882 str_pos = str_ptr - mask;
15883
15884 // escaped separator, i.e. "\,"
15885
15886 if (str_pos > 0)
15887 {
15888 if (mask[str_pos - 1] == '\\')
15889 {
15890 separator_cnt --;
15891
15892 mask_offset = str_pos + 1;
15893
15894 continue;
15895 }
15896 }
15897
15898 // reset the offset
15899
15900 mask_offset = 0;
15901
15902 mask[str_pos] = '\0';
15903
15904 switch (separator_cnt)
15905 {
15906 case 0:
15907 mp_reset_usr (mp_usr, 0);
15908
15909 custom_charset_1 = mask;
15910 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15911 break;
15912
15913 case 1:
15914 mp_reset_usr (mp_usr, 1);
15915
15916 custom_charset_2 = mask;
15917 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15918 break;
15919
15920 case 2:
15921 mp_reset_usr (mp_usr, 2);
15922
15923 custom_charset_3 = mask;
15924 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15925 break;
15926
15927 case 3:
15928 mp_reset_usr (mp_usr, 3);
15929
15930 custom_charset_4 = mask;
15931 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15932 break;
15933 }
15934
15935 mask = mask + str_pos + 1;
15936 }
15937 }
15938
15939 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15940 {
15941 if (maskpos > 0)
15942 {
15943 local_free (css_buf);
15944 local_free (data.root_css_buf);
15945 local_free (data.markov_css_buf);
15946
15947 local_free (masks[maskpos - 1]);
15948 }
15949
15950 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15951
15952 data.mask = mask;
15953 data.css_cnt = css_cnt;
15954 data.css_buf = css_buf;
15955
15956 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15957
15958 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15959
15960 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15961 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15962
15963 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15964
15965 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15966
15967 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15968 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15969
15970 data.root_css_buf = root_css_buf;
15971 data.markov_css_buf = markov_css_buf;
15972
15973 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15974
15975 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15976
15977 local_free (root_table_buf);
15978 local_free (markov_table_buf);
15979
15980 // args
15981
15982 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15983 {
15984 hc_device_param_t *device_param = &data.devices_param[device_id];
15985
15986 if (device_param->skipped) continue;
15987
15988 device_param->kernel_params_mp[0] = &device_param->d_combs;
15989 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15990 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15991
15992 device_param->kernel_params_mp_buf64[3] = 0;
15993 device_param->kernel_params_mp_buf32[4] = css_cnt;
15994 device_param->kernel_params_mp_buf32[5] = 0;
15995 device_param->kernel_params_mp_buf32[6] = 0;
15996 device_param->kernel_params_mp_buf32[7] = 0;
15997
15998 if (attack_mode == ATTACK_MODE_HYBRID1)
15999 {
16000 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
16001 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
16002 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
16003 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
16004 }
16005 else if (attack_mode == ATTACK_MODE_HYBRID2)
16006 {
16007 device_param->kernel_params_mp_buf32[5] = 0;
16008 device_param->kernel_params_mp_buf32[6] = 0;
16009 device_param->kernel_params_mp_buf32[7] = 0;
16010 }
16011
16012 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]);
16013 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]);
16014 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]);
16015
16016 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);
16017 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);
16018 }
16019 }
16020 else if (attack_mode == ATTACK_MODE_BF)
16021 {
16022 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
16023
16024 if (increment)
16025 {
16026 for (uint i = 0; i < dictcnt; i++)
16027 {
16028 local_free (dictfiles[i]);
16029 }
16030
16031 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
16032 {
16033 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
16034
16035 if (l1_filename == NULL) break;
16036
16037 dictcnt++;
16038
16039 dictfiles[dictcnt - 1] = l1_filename;
16040 }
16041 }
16042 else
16043 {
16044 dictcnt++;
16045
16046 dictfiles[dictcnt - 1] = mask;
16047 }
16048
16049 if (dictcnt == 0)
16050 {
16051 log_error ("ERROR: Mask is too small");
16052
16053 return (-1);
16054 }
16055 }
16056 }
16057
16058 free (induction_dictionaries);
16059
16060 // induction_dictionaries_cnt = 0; // implied
16061
16062 if (attack_mode != ATTACK_MODE_BF)
16063 {
16064 if (keyspace == 0)
16065 {
16066 induction_dictionaries = scan_directory (induction_directory);
16067
16068 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16069 }
16070 }
16071
16072 if (induction_dictionaries_cnt)
16073 {
16074 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16075 }
16076
16077 /**
16078 * prevent the user from using --keyspace together w/ maskfile and or dictfile
16079 */
16080 if (keyspace == 1)
16081 {
16082 if ((maskcnt > 1) || (dictcnt > 1))
16083 {
16084 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
16085
16086 return (-1);
16087 }
16088 }
16089
16090 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
16091 {
16092 char *subid = logfile_generate_subid ();
16093
16094 data.subid = subid;
16095
16096 logfile_sub_msg ("START");
16097
16098 data.devices_status = STATUS_INIT;
16099
16100 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
16101 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
16102 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
16103
16104 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
16105
16106 data.cpt_pos = 0;
16107
16108 data.cpt_start = time (NULL);
16109
16110 data.cpt_total = 0;
16111
16112 if (data.restore == 0)
16113 {
16114 rd->words_cur = skip;
16115
16116 skip = 0;
16117
16118 data.skip = 0;
16119 }
16120
16121 data.ms_paused = 0;
16122
16123 data.words_cur = rd->words_cur;
16124
16125 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16126 {
16127 hc_device_param_t *device_param = &data.devices_param[device_id];
16128
16129 if (device_param->skipped) continue;
16130
16131 device_param->speed_pos = 0;
16132
16133 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
16134 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
16135
16136 device_param->exec_pos = 0;
16137
16138 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
16139
16140 device_param->kernel_power = device_param->kernel_power_user;
16141
16142 device_param->outerloop_pos = 0;
16143 device_param->outerloop_left = 0;
16144 device_param->innerloop_pos = 0;
16145 device_param->innerloop_left = 0;
16146
16147 // some more resets:
16148
16149 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
16150
16151 device_param->pws_cnt = 0;
16152
16153 device_param->words_off = 0;
16154 device_param->words_done = 0;
16155 }
16156
16157 data.kernel_power_div = 0;
16158
16159 // figure out some workload
16160
16161 if (attack_mode == ATTACK_MODE_STRAIGHT)
16162 {
16163 if (data.wordlist_mode == WL_MODE_FILE)
16164 {
16165 char *dictfile = NULL;
16166
16167 if (induction_dictionaries_cnt)
16168 {
16169 dictfile = induction_dictionaries[0];
16170 }
16171 else
16172 {
16173 dictfile = dictfiles[dictpos];
16174 }
16175
16176 data.dictfile = dictfile;
16177
16178 logfile_sub_string (dictfile);
16179
16180 for (uint i = 0; i < rp_files_cnt; i++)
16181 {
16182 logfile_sub_var_string ("rulefile", rp_files[i]);
16183 }
16184
16185 FILE *fd2 = fopen (dictfile, "rb");
16186
16187 if (fd2 == NULL)
16188 {
16189 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16190
16191 return (-1);
16192 }
16193
16194 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16195
16196 fclose (fd2);
16197
16198 if (data.words_cnt == 0)
16199 {
16200 if (data.devices_status == STATUS_CRACKED) break;
16201 if (data.devices_status == STATUS_ABORTED) break;
16202
16203 dictpos++;
16204
16205 continue;
16206 }
16207 }
16208 }
16209 else if (attack_mode == ATTACK_MODE_COMBI)
16210 {
16211 char *dictfile = data.dictfile;
16212 char *dictfile2 = data.dictfile2;
16213
16214 logfile_sub_string (dictfile);
16215 logfile_sub_string (dictfile2);
16216
16217 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
16218 {
16219 FILE *fd2 = fopen (dictfile, "rb");
16220
16221 if (fd2 == NULL)
16222 {
16223 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16224
16225 return (-1);
16226 }
16227
16228 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16229
16230 fclose (fd2);
16231 }
16232 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
16233 {
16234 FILE *fd2 = fopen (dictfile2, "rb");
16235
16236 if (fd2 == NULL)
16237 {
16238 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16239
16240 return (-1);
16241 }
16242
16243 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
16244
16245 fclose (fd2);
16246 }
16247
16248 if (data.words_cnt == 0)
16249 {
16250 if (data.devices_status == STATUS_CRACKED) break;
16251 if (data.devices_status == STATUS_ABORTED) break;
16252
16253 dictpos++;
16254
16255 continue;
16256 }
16257 }
16258 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16259 {
16260 char *dictfile = NULL;
16261
16262 if (induction_dictionaries_cnt)
16263 {
16264 dictfile = induction_dictionaries[0];
16265 }
16266 else
16267 {
16268 dictfile = dictfiles[dictpos];
16269 }
16270
16271 data.dictfile = dictfile;
16272
16273 char *mask = data.mask;
16274
16275 logfile_sub_string (dictfile);
16276 logfile_sub_string (mask);
16277
16278 FILE *fd2 = fopen (dictfile, "rb");
16279
16280 if (fd2 == NULL)
16281 {
16282 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16283
16284 return (-1);
16285 }
16286
16287 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16288
16289 fclose (fd2);
16290
16291 if (data.words_cnt == 0)
16292 {
16293 if (data.devices_status == STATUS_CRACKED) break;
16294 if (data.devices_status == STATUS_ABORTED) break;
16295
16296 dictpos++;
16297
16298 continue;
16299 }
16300 }
16301 else if (attack_mode == ATTACK_MODE_BF)
16302 {
16303 local_free (css_buf);
16304 local_free (data.root_css_buf);
16305 local_free (data.markov_css_buf);
16306
16307 char *mask = dictfiles[dictpos];
16308
16309 logfile_sub_string (mask);
16310
16311 // base
16312
16313 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16314
16315 if (opts_type & OPTS_TYPE_PT_UNICODE)
16316 {
16317 uint css_cnt_unicode = css_cnt * 2;
16318
16319 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
16320
16321 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
16322 {
16323 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
16324
16325 css_buf_unicode[j + 1].cs_buf[0] = 0;
16326 css_buf_unicode[j + 1].cs_len = 1;
16327 }
16328
16329 free (css_buf);
16330
16331 css_buf = css_buf_unicode;
16332 css_cnt = css_cnt_unicode;
16333 }
16334
16335 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
16336
16337 uint mask_min = pw_min;
16338 uint mask_max = pw_max;
16339
16340 if (opts_type & OPTS_TYPE_PT_UNICODE)
16341 {
16342 mask_min *= 2;
16343 mask_max *= 2;
16344 }
16345
16346 if ((css_cnt < mask_min) || (css_cnt > mask_max))
16347 {
16348 if (css_cnt < mask_min)
16349 {
16350 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
16351 }
16352
16353 if (css_cnt > mask_max)
16354 {
16355 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
16356 }
16357
16358 // skip to next mask
16359
16360 dictpos++;
16361
16362 rd->dictpos = dictpos;
16363
16364 logfile_sub_msg ("STOP");
16365
16366 continue;
16367 }
16368
16369 uint save_css_cnt = css_cnt;
16370
16371 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16372 {
16373 if (opti_type & OPTI_TYPE_APPENDED_SALT)
16374 {
16375 uint salt_len = (uint) data.salts_buf[0].salt_len;
16376 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
16377
16378 uint css_cnt_salt = css_cnt + salt_len;
16379
16380 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
16381
16382 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
16383
16384 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
16385 {
16386 css_buf_salt[j].cs_buf[0] = salt_buf[i];
16387 css_buf_salt[j].cs_len = 1;
16388 }
16389
16390 free (css_buf);
16391
16392 css_buf = css_buf_salt;
16393 css_cnt = css_cnt_salt;
16394 }
16395 }
16396
16397 data.mask = mask;
16398 data.css_cnt = css_cnt;
16399 data.css_buf = css_buf;
16400
16401 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
16402
16403 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16404
16405 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16406
16407 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16408 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16409
16410 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16411
16412 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16413
16414 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16415 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16416
16417 data.root_css_buf = root_css_buf;
16418 data.markov_css_buf = markov_css_buf;
16419
16420 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16421
16422 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16423
16424 local_free (root_table_buf);
16425 local_free (markov_table_buf);
16426
16427 // copy + args
16428
16429 uint css_cnt_l = css_cnt;
16430 uint css_cnt_r;
16431
16432 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16433 {
16434 if (save_css_cnt < 6)
16435 {
16436 css_cnt_r = 1;
16437 }
16438 else if (save_css_cnt == 6)
16439 {
16440 css_cnt_r = 2;
16441 }
16442 else
16443 {
16444 if (opts_type & OPTS_TYPE_PT_UNICODE)
16445 {
16446 if (save_css_cnt == 8 || save_css_cnt == 10)
16447 {
16448 css_cnt_r = 2;
16449 }
16450 else
16451 {
16452 css_cnt_r = 4;
16453 }
16454 }
16455 else
16456 {
16457 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
16458 {
16459 css_cnt_r = 3;
16460 }
16461 else
16462 {
16463 css_cnt_r = 4;
16464 }
16465 }
16466 }
16467 }
16468 else
16469 {
16470 css_cnt_r = 1;
16471
16472 /* unfinished code?
16473 int sum = css_buf[css_cnt_r - 1].cs_len;
16474
16475 for (uint i = 1; i < 4 && i < css_cnt; i++)
16476 {
16477 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
16478
16479 css_cnt_r++;
16480
16481 sum *= css_buf[css_cnt_r - 1].cs_len;
16482 }
16483 */
16484 }
16485
16486 css_cnt_l -= css_cnt_r;
16487
16488 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
16489
16490 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16491 {
16492 hc_device_param_t *device_param = &data.devices_param[device_id];
16493
16494 if (device_param->skipped) continue;
16495
16496 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
16497 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
16498 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
16499
16500 device_param->kernel_params_mp_l_buf64[3] = 0;
16501 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
16502 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
16503 device_param->kernel_params_mp_l_buf32[6] = 0;
16504 device_param->kernel_params_mp_l_buf32[7] = 0;
16505 device_param->kernel_params_mp_l_buf32[8] = 0;
16506
16507 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
16508 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
16509 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
16510 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
16511
16512 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
16513 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
16514 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
16515
16516 device_param->kernel_params_mp_r_buf64[3] = 0;
16517 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
16518 device_param->kernel_params_mp_r_buf32[5] = 0;
16519 device_param->kernel_params_mp_r_buf32[6] = 0;
16520 device_param->kernel_params_mp_r_buf32[7] = 0;
16521
16522 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]);
16523 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]);
16524 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]);
16525
16526 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]);
16527 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]);
16528 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]);
16529
16530 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);
16531 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);
16532 }
16533 }
16534
16535 u64 words_base = data.words_cnt;
16536
16537 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16538 {
16539 if (data.kernel_rules_cnt)
16540 {
16541 words_base /= data.kernel_rules_cnt;
16542 }
16543 }
16544 else if (data.attack_kern == ATTACK_KERN_COMBI)
16545 {
16546 if (data.combs_cnt)
16547 {
16548 words_base /= data.combs_cnt;
16549 }
16550 }
16551 else if (data.attack_kern == ATTACK_KERN_BF)
16552 {
16553 if (data.bfs_cnt)
16554 {
16555 words_base /= data.bfs_cnt;
16556 }
16557 }
16558
16559 data.words_base = words_base;
16560
16561 if (keyspace == 1)
16562 {
16563 log_info ("%llu", (unsigned long long int) words_base);
16564
16565 return (0);
16566 }
16567
16568 if (data.words_cur > data.words_base)
16569 {
16570 log_error ("ERROR: restore value greater keyspace");
16571
16572 return (-1);
16573 }
16574
16575 if (data.words_cur)
16576 {
16577 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16578 {
16579 for (uint i = 0; i < data.salts_cnt; i++)
16580 {
16581 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16582 }
16583 }
16584 else if (data.attack_kern == ATTACK_KERN_COMBI)
16585 {
16586 for (uint i = 0; i < data.salts_cnt; i++)
16587 {
16588 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16589 }
16590 }
16591 else if (data.attack_kern == ATTACK_KERN_BF)
16592 {
16593 for (uint i = 0; i < data.salts_cnt; i++)
16594 {
16595 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16596 }
16597 }
16598 }
16599
16600 /*
16601 * Inform user about possible slow speeds
16602 */
16603
16604 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16605 {
16606 if (data.words_base < kernel_power_all)
16607 {
16608 if (quiet == 0)
16609 {
16610 log_info ("");
16611 log_info ("ATTENTION!");
16612 log_info (" The wordlist or mask you are using is too small.");
16613 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
16614 log_info (" The cracking speed will drop.");
16615 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16616 log_info ("");
16617 }
16618 }
16619 }
16620
16621 /*
16622 * Update loopback file
16623 */
16624
16625 if (loopback == 1)
16626 {
16627 time_t now;
16628
16629 time (&now);
16630
16631 uint random_num = get_random_num (0, 9999);
16632
16633 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16634
16635 data.loopback_file = loopback_file;
16636 }
16637
16638 /*
16639 * Update dictionary statistic
16640 */
16641
16642 if (keyspace == 0)
16643 {
16644 dictstat_fp = fopen (dictstat, "wb");
16645
16646 if (dictstat_fp)
16647 {
16648 lock_file (dictstat_fp);
16649
16650 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16651
16652 fclose (dictstat_fp);
16653 }
16654 }
16655
16656 data.devices_status = STATUS_RUNNING;
16657
16658 if (initial_restore_done == 0)
16659 {
16660 if (data.restore_disable == 0) cycle_restore ();
16661
16662 initial_restore_done = 1;
16663 }
16664
16665 hc_timer_set (&data.timer_running);
16666
16667 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16668 {
16669 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16670 {
16671 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16672 if (quiet == 0) fflush (stdout);
16673 }
16674 }
16675 else if (wordlist_mode == WL_MODE_STDIN)
16676 {
16677 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16678 if (data.quiet == 0) log_info ("");
16679 }
16680
16681 time_t runtime_start;
16682
16683 time (&runtime_start);
16684
16685 data.runtime_start = runtime_start;
16686
16687 /**
16688 * create cracker threads
16689 */
16690
16691 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
16692
16693 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16694 {
16695 hc_device_param_t *device_param = &devices_param[device_id];
16696
16697 if (wordlist_mode == WL_MODE_STDIN)
16698 {
16699 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16700 }
16701 else
16702 {
16703 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16704 }
16705 }
16706
16707 // wait for crack threads to exit
16708
16709 hc_thread_wait (data.devices_cnt, c_threads);
16710
16711 local_free (c_threads);
16712
16713 data.restore = 0;
16714
16715 // finalize task
16716
16717 logfile_sub_var_uint ("status-after-work", data.devices_status);
16718
16719 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16720
16721 if (data.devices_status == STATUS_CRACKED) break;
16722 if (data.devices_status == STATUS_ABORTED) break;
16723
16724 if (data.devices_status == STATUS_BYPASS)
16725 {
16726 data.devices_status = STATUS_RUNNING;
16727 }
16728
16729 if (induction_dictionaries_cnt)
16730 {
16731 unlink (induction_dictionaries[0]);
16732 }
16733
16734 free (induction_dictionaries);
16735
16736 if (attack_mode != ATTACK_MODE_BF)
16737 {
16738 induction_dictionaries = scan_directory (induction_directory);
16739
16740 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16741 }
16742
16743 if (benchmark == 0)
16744 {
16745 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16746 {
16747 if (quiet == 0) clear_prompt ();
16748
16749 if (quiet == 0) log_info ("");
16750
16751 if (status == 1)
16752 {
16753 status_display ();
16754 }
16755 else
16756 {
16757 if (quiet == 0) status_display ();
16758 }
16759
16760 if (quiet == 0) log_info ("");
16761 }
16762 }
16763
16764 if (attack_mode == ATTACK_MODE_BF)
16765 {
16766 dictpos++;
16767
16768 rd->dictpos = dictpos;
16769 }
16770 else
16771 {
16772 if (induction_dictionaries_cnt)
16773 {
16774 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16775 }
16776 else
16777 {
16778 dictpos++;
16779
16780 rd->dictpos = dictpos;
16781 }
16782 }
16783
16784 time_t runtime_stop;
16785
16786 time (&runtime_stop);
16787
16788 data.runtime_stop = runtime_stop;
16789
16790 logfile_sub_uint (runtime_start);
16791 logfile_sub_uint (runtime_stop);
16792
16793 logfile_sub_msg ("STOP");
16794
16795 global_free (subid);
16796 }
16797
16798 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16799
16800 if (data.devices_status == STATUS_CRACKED) break;
16801 if (data.devices_status == STATUS_ABORTED) break;
16802 if (data.devices_status == STATUS_QUIT) break;
16803
16804 if (data.devices_status == STATUS_BYPASS)
16805 {
16806 data.devices_status = STATUS_RUNNING;
16807 }
16808 }
16809
16810 // 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
16811
16812 if (attack_mode == ATTACK_MODE_STRAIGHT)
16813 {
16814 if (data.wordlist_mode == WL_MODE_FILE)
16815 {
16816 if (data.dictfile == NULL)
16817 {
16818 if (dictfiles != NULL)
16819 {
16820 data.dictfile = dictfiles[0];
16821
16822 hc_timer_set (&data.timer_running);
16823 }
16824 }
16825 }
16826 }
16827 // NOTE: combi is okay because it is already set beforehand
16828 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16829 {
16830 if (data.dictfile == NULL)
16831 {
16832 if (dictfiles != NULL)
16833 {
16834 hc_timer_set (&data.timer_running);
16835
16836 data.dictfile = dictfiles[0];
16837 }
16838 }
16839 }
16840 else if (attack_mode == ATTACK_MODE_BF)
16841 {
16842 if (data.mask == NULL)
16843 {
16844 hc_timer_set (&data.timer_running);
16845
16846 data.mask = masks[0];
16847 }
16848 }
16849
16850 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16851 {
16852 data.devices_status = STATUS_EXHAUSTED;
16853 }
16854
16855 // if cracked / aborted remove last induction dictionary
16856
16857 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16858 {
16859 struct stat induct_stat;
16860
16861 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16862 {
16863 unlink (induction_dictionaries[file_pos]);
16864 }
16865 }
16866
16867 // wait for non-interactive threads
16868
16869 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16870 {
16871 hc_thread_wait (1, &ni_threads[thread_idx]);
16872 }
16873
16874 local_free (ni_threads);
16875
16876 // wait for interactive threads
16877
16878 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16879 {
16880 hc_thread_wait (1, &i_thread);
16881 }
16882
16883 // we dont need restore file anymore
16884 if (data.restore_disable == 0)
16885 {
16886 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16887 {
16888 unlink (eff_restore_file);
16889 unlink (new_restore_file);
16890 }
16891 else
16892 {
16893 cycle_restore ();
16894 }
16895 }
16896
16897 // finally save left hashes
16898
16899 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16900 {
16901 save_hash ();
16902 }
16903
16904 /**
16905 * Clean up
16906 */
16907
16908 if (benchmark == 1)
16909 {
16910 status_benchmark ();
16911
16912 log_info ("");
16913 }
16914 else
16915 {
16916 if (quiet == 0) clear_prompt ();
16917
16918 if (quiet == 0) log_info ("");
16919
16920 if (status == 1)
16921 {
16922 status_display ();
16923 }
16924 else
16925 {
16926 if (quiet == 0) status_display ();
16927 }
16928
16929 if (quiet == 0) log_info ("");
16930 }
16931
16932 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16933 {
16934 hc_device_param_t *device_param = &data.devices_param[device_id];
16935
16936 if (device_param->skipped) continue;
16937
16938 local_free (device_param->result);
16939
16940 local_free (device_param->combs_buf);
16941
16942 local_free (device_param->hooks_buf);
16943
16944 local_free (device_param->device_name);
16945
16946 local_free (device_param->device_name_chksum);
16947
16948 local_free (device_param->device_version);
16949
16950 local_free (device_param->driver_version);
16951
16952 if (device_param->pws_buf) myfree (device_param->pws_buf);
16953 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
16954 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
16955 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
16956 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
16957 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
16958 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
16959 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
16960 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
16961 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
16962 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
16963 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
16964 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
16965 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
16966 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
16967 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
16968 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
16969 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
16970 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
16971 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
16972 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
16973 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
16974 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
16975 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
16976 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
16977 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
16978 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
16979 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
16980 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
16981
16982 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
16983 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
16984 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
16985 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
16986 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
16987 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
16988 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
16989 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
16990 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
16991 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
16992
16993 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
16994 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
16995 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
16996
16997 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
16998 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
16999 }
17000
17001 // reset default fan speed
17002
17003 #ifdef HAVE_HWMON
17004 if (gpu_temp_disable == 0)
17005 {
17006 #ifdef HAVE_ADL
17007 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
17008 {
17009 hc_thread_mutex_lock (mux_adl);
17010
17011 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17012 {
17013 hc_device_param_t *device_param = &data.devices_param[device_id];
17014
17015 if (device_param->skipped) continue;
17016
17017 if (data.hm_device[device_id].fan_supported == 1)
17018 {
17019 int fanspeed = temp_retain_fanspeed_value[device_id];
17020
17021 if (fanspeed == -1) continue;
17022
17023 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
17024
17025 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
17026 }
17027 }
17028
17029 hc_thread_mutex_unlock (mux_adl);
17030 }
17031 #endif // HAVE_ADL
17032 }
17033
17034 #ifdef HAVE_ADL
17035 // reset power tuning
17036
17037 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
17038 {
17039 hc_thread_mutex_lock (mux_adl);
17040
17041 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17042 {
17043 hc_device_param_t *device_param = &data.devices_param[device_id];
17044
17045 if (device_param->skipped) continue;
17046
17047 if (data.hm_device[device_id].od_version == 6)
17048 {
17049 // check powertune capabilities first, if not available then skip device
17050
17051 int powertune_supported = 0;
17052
17053 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
17054 {
17055 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
17056
17057 return (-1);
17058 }
17059
17060 if (powertune_supported != 0)
17061 {
17062 // powercontrol settings
17063
17064 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)
17065 {
17066 log_info ("ERROR: Failed to restore the ADL PowerControl values");
17067
17068 return (-1);
17069 }
17070
17071 // clocks
17072
17073 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
17074
17075 performance_state->iNumberOfPerformanceLevels = 2;
17076
17077 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
17078 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
17079 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
17080 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
17081
17082 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)
17083 {
17084 log_info ("ERROR: Failed to restore ADL performance state");
17085
17086 return (-1);
17087 }
17088
17089 local_free (performance_state);
17090 }
17091 }
17092 }
17093
17094 hc_thread_mutex_unlock (mux_adl);
17095 }
17096 #endif // HAVE_ADL
17097
17098 if (gpu_temp_disable == 0)
17099 {
17100 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
17101 if (data.hm_nv)
17102 {
17103 #if defined(LINUX) && defined(HAVE_NVML)
17104
17105 hm_NVML_nvmlShutdown (data.hm_nv);
17106
17107 nvml_close (data.hm_nv);
17108
17109 #elif defined(WIN) && (HAVE_NVAPI)
17110
17111 hm_NvAPI_Unload (data.hm_nv);
17112
17113 nvapi_close (data.hm_nv);
17114
17115 #endif
17116
17117 data.hm_nv = NULL;
17118 }
17119 #endif
17120
17121 #ifdef HAVE_ADL
17122 if (data.hm_amd)
17123 {
17124 hm_ADL_Main_Control_Destroy (data.hm_amd);
17125
17126 adl_close (data.hm_amd);
17127 data.hm_amd = NULL;
17128 }
17129 #endif
17130 }
17131 #endif // HAVE_HWMON
17132
17133 // free memory
17134
17135 local_free (masks);
17136
17137 local_free (dictstat_base);
17138
17139 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
17140 {
17141 pot_t *pot_ptr = &pot[pot_pos];
17142
17143 hash_t *hash = &pot_ptr->hash;
17144
17145 local_free (hash->digest);
17146
17147 if (isSalted)
17148 {
17149 local_free (hash->salt);
17150 }
17151 }
17152
17153 local_free (pot);
17154
17155 local_free (all_kernel_rules_cnt);
17156 local_free (all_kernel_rules_buf);
17157
17158 local_free (wl_data->buf);
17159 local_free (wl_data);
17160
17161 local_free (bitmap_s1_a);
17162 local_free (bitmap_s1_b);
17163 local_free (bitmap_s1_c);
17164 local_free (bitmap_s1_d);
17165 local_free (bitmap_s2_a);
17166 local_free (bitmap_s2_b);
17167 local_free (bitmap_s2_c);
17168 local_free (bitmap_s2_d);
17169
17170 #ifdef HAVE_HWMON
17171 local_free (temp_retain_fanspeed_value);
17172 #ifdef HAVE_ADL
17173 local_free (od_clock_mem_status);
17174 local_free (od_power_control_status);
17175 #endif // ADL
17176 #endif
17177
17178 global_free (devices_param);
17179
17180 global_free (kernel_rules_buf);
17181
17182 global_free (root_css_buf);
17183 global_free (markov_css_buf);
17184
17185 global_free (digests_buf);
17186 global_free (digests_shown);
17187 global_free (digests_shown_tmp);
17188
17189 global_free (salts_buf);
17190 global_free (salts_shown);
17191
17192 global_free (esalts_buf);
17193
17194 global_free (words_progress_done);
17195 global_free (words_progress_rejected);
17196 global_free (words_progress_restored);
17197
17198 if (pot_fp) fclose (pot_fp);
17199
17200 if (data.devices_status == STATUS_QUIT) break;
17201 }
17202
17203 // destroy others mutex
17204
17205 hc_thread_mutex_delete (mux_dispatcher);
17206 hc_thread_mutex_delete (mux_counter);
17207 hc_thread_mutex_delete (mux_display);
17208 hc_thread_mutex_delete (mux_adl);
17209
17210 // free memory
17211
17212 local_free (eff_restore_file);
17213 local_free (new_restore_file);
17214
17215 local_free (rd);
17216
17217 // tuning db
17218
17219 tuning_db_destroy (tuning_db);
17220
17221 // loopback
17222
17223 local_free (loopback_file);
17224
17225 if (loopback == 1) unlink (loopback_file);
17226
17227 // induction directory
17228
17229 if (induction_dir == NULL)
17230 {
17231 if (attack_mode != ATTACK_MODE_BF)
17232 {
17233 if (rmdir (induction_directory) == -1)
17234 {
17235 if (errno == ENOENT)
17236 {
17237 // good, we can ignore
17238 }
17239 else if (errno == ENOTEMPTY)
17240 {
17241 // good, we can ignore
17242 }
17243 else
17244 {
17245 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
17246
17247 return (-1);
17248 }
17249 }
17250
17251 local_free (induction_directory);
17252 }
17253 }
17254
17255 // outfile-check directory
17256
17257 if (outfile_check_dir == NULL)
17258 {
17259 if (rmdir (outfile_check_directory) == -1)
17260 {
17261 if (errno == ENOENT)
17262 {
17263 // good, we can ignore
17264 }
17265 else if (errno == ENOTEMPTY)
17266 {
17267 // good, we can ignore
17268 }
17269 else
17270 {
17271 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
17272
17273 return (-1);
17274 }
17275 }
17276
17277 local_free (outfile_check_directory);
17278 }
17279
17280 time_t proc_stop;
17281
17282 time (&proc_stop);
17283
17284 logfile_top_uint (proc_start);
17285 logfile_top_uint (proc_stop);
17286
17287 logfile_top_msg ("STOP");
17288
17289 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
17290 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
17291
17292 if (data.ocl) ocl_close (data.ocl);
17293
17294 if (data.devices_status == STATUS_ABORTED) return 2;
17295 if (data.devices_status == STATUS_QUIT) return 2;
17296 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
17297 if (data.devices_status == STATUS_EXHAUSTED) return 1;
17298 if (data.devices_status == STATUS_CRACKED) return 0;
17299
17300 return -1;
17301 }
Hashcat additions to support pwdhash