projects / hashcat.git / blob
? search:


1c8634eae91674c01c19864bbf8deb6aad412aa7
[hashcat.git] / src / oclHashcat.c
1 /**
2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
5 *
6 * License.....: MIT
7 */
8
9 #ifdef OSX
10 #include <stdio.h>
11 #endif
12
13 #include <common.h>
14 #include <shared.h>
15 #include <rp_kernel_on_cpu.h>
16 #include <getopt.h>
17
18 const char *PROGNAME = "oclHashcat";
19 const uint VERSION_BIN = 210;
20 const uint RESTORE_MIN = 210;
21
22 double TARGET_MS_PROFILE[3] = { 8, 16, 96 };
23
24 #define INCR_RULES 10000
25 #define INCR_SALTS 100000
26 #define INCR_MASKS 1000
27 #define INCR_POT 1000
28
29 #define USAGE 0
30 #define VERSION 0
31 #define QUIET 0
32 #define MARKOV_THRESHOLD 0
33 #define MARKOV_DISABLE 0
34 #define MARKOV_CLASSIC 0
35 #define BENCHMARK 0
36 #define BENCHMARK_REPEATS 100
37 #define RESTORE 0
38 #define RESTORE_TIMER 60
39 #define RESTORE_DISABLE 0
40 #define STATUS 0
41 #define STATUS_TIMER 10
42 #define STATUS_AUTOMAT 0
43 #define LOOPBACK 0
44 #define WEAK_HASH_THRESHOLD 100
45 #define SHOW 0
46 #define LEFT 0
47 #define USERNAME 0
48 #define REMOVE 0
49 #define REMOVE_TIMER 60
50 #define SKIP 0
51 #define LIMIT 0
52 #define KEYSPACE 0
53 #define POTFILE_DISABLE 0
54 #define DEBUG_MODE 0
55 #define RP_GEN 0
56 #define RP_GEN_FUNC_MIN 1
57 #define RP_GEN_FUNC_MAX 4
58 #define RP_GEN_SEED 0
59 #define RULE_BUF_L ":"
60 #define RULE_BUF_R ":"
61 #define FORCE 0
62 #define RUNTIME 0
63 #define HEX_CHARSET 0
64 #define HEX_SALT 0
65 #define HEX_WORDLIST 0
66 #define OUTFILE_FORMAT 3
67 #define OUTFILE_AUTOHEX 1
68 #define OUTFILE_CHECK_TIMER 5
69 #define ATTACK_MODE 0
70 #define HASH_MODE 0
71 #define SEGMENT_SIZE 32
72 #define INCREMENT 0
73 #define INCREMENT_MIN 1
74 #define INCREMENT_MAX PW_MAX
75 #define SEPARATOR ':'
76 #define BITMAP_MIN 16
77 #define BITMAP_MAX 24
78 #define GPU_TEMP_DISABLE 0
79 #define GPU_TEMP_ABORT 90
80 #define GPU_TEMP_RETAIN 80
81 #define WORKLOAD_PROFILE 2
82 #define KERNEL_ACCEL 0
83 #define KERNEL_LOOPS 0
84 #define KERNEL_RULES 1024
85 #define KERNEL_COMBS 1024
86 #define KERNEL_BFS 1024
87 #define KERNEL_THREADS 64
88 #define POWERTUNE_ENABLE 0
89 #define LOGFILE_DISABLE 0
90 #define SCRYPT_TMTO 0
91 #define OPENCL_VECTOR_WIDTH 0
92
93 #define WL_MODE_STDIN 1
94 #define WL_MODE_FILE 2
95 #define WL_MODE_MASK 3
96
97 #define HL_MODE_FILE 4
98 #define HL_MODE_ARG 5
99
100 #define HLFMTS_CNT 11
101 #define HLFMT_HASHCAT 0
102 #define HLFMT_PWDUMP 1
103 #define HLFMT_PASSWD 2
104 #define HLFMT_SHADOW 3
105 #define HLFMT_DCC 4
106 #define HLFMT_DCC2 5
107 #define HLFMT_NETNTLM1 7
108 #define HLFMT_NETNTLM2 8
109 #define HLFMT_NSLDAP 9
110 #define HLFMT_NSLDAPS 10
111
112 #define HLFMT_TEXT_HASHCAT "native hashcat"
113 #define HLFMT_TEXT_PWDUMP "pwdump"
114 #define HLFMT_TEXT_PASSWD "passwd"
115 #define HLFMT_TEXT_SHADOW "shadow"
116 #define HLFMT_TEXT_DCC "DCC"
117 #define HLFMT_TEXT_DCC2 "DCC 2"
118 #define HLFMT_TEXT_NETNTLM1 "NetNTLMv1"
119 #define HLFMT_TEXT_NETNTLM2 "NetNTLMv2"
120 #define HLFMT_TEXT_NSLDAP "nsldap"
121 #define HLFMT_TEXT_NSLDAPS "nsldaps"
122
123 #define ATTACK_MODE_STRAIGHT 0
124 #define ATTACK_MODE_COMBI 1
125 #define ATTACK_MODE_TOGGLE 2
126 #define ATTACK_MODE_BF 3
127 #define ATTACK_MODE_PERM 4
128 #define ATTACK_MODE_TABLE 5
129 #define ATTACK_MODE_HYBRID1 6
130 #define ATTACK_MODE_HYBRID2 7
131 #define ATTACK_MODE_NONE 100
132
133 #define ATTACK_KERN_STRAIGHT 0
134 #define ATTACK_KERN_COMBI 1
135 #define ATTACK_KERN_BF 3
136 #define ATTACK_KERN_NONE 100
137
138 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
139 #define ATTACK_EXEC_INSIDE_KERNEL 11
140
141 #define COMBINATOR_MODE_BASE_LEFT 10001
142 #define COMBINATOR_MODE_BASE_RIGHT 10002
143
144 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
145 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
146
147 #define MAX_CUT_TRIES 4
148
149 #define MAX_DICTSTAT 10000
150
151 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 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 * oclHashcat 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 * oclHashcat -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 < 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 = 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 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), &workgroup_size, NULL);
2525 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2526
2527 const size_t global_work_size[3] = { num_elements, 1, 1 };
2528 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2529
2530 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2531
2532 hc_clFlush (data.ocl, device_param->command_queue);
2533
2534 hc_clFinish (data.ocl, device_param->command_queue);
2535 }
2536
2537 static void run_kernel_tm (hc_device_param_t *device_param)
2538 {
2539 const uint num_elements = 1024; // fixed
2540
2541 uint kernel_threads = 32;
2542
2543 cl_kernel kernel = device_param->kernel_tm;
2544
2545 size_t workgroup_size = 0;
2546 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2547 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2548
2549 const size_t global_work_size[3] = { num_elements, 1, 1 };
2550 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2551
2552 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2553
2554 hc_clFlush (data.ocl, device_param->command_queue);
2555
2556 hc_clFinish (data.ocl, device_param->command_queue);
2557 }
2558
2559 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2560 {
2561 uint num_elements = num;
2562
2563 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2564 device_param->kernel_params_amp_buf32[6] = num_elements;
2565
2566 // causes problems with special threads like in bcrypt
2567 // const uint kernel_threads = device_param->kernel_threads;
2568
2569 uint kernel_threads = KERNEL_THREADS;
2570
2571 while (num_elements % kernel_threads) num_elements++;
2572
2573 cl_kernel kernel = device_param->kernel_amp;
2574
2575 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2576 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2577
2578 size_t workgroup_size = 0;
2579 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2580 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2581
2582 const size_t global_work_size[3] = { num_elements, 1, 1 };
2583 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2584
2585 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2586
2587 hc_clFlush (data.ocl, device_param->command_queue);
2588
2589 hc_clFinish (data.ocl, device_param->command_queue);
2590 }
2591
2592 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2593 {
2594 int rc = -1;
2595
2596 if (device_param->opencl_v12 && device_param->vendor_id == VENDOR_ID_AMD)
2597 {
2598 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2599
2600 const cl_uchar zero = 0;
2601
2602 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2603 }
2604
2605 if (rc != 0)
2606 {
2607 // NOTE: clEnqueueFillBuffer () always fails with -59
2608 // IOW, it's not supported by Nvidia ForceWare <= 352.21, also pocl segfaults, also on apple
2609 // How's that possible, OpenCL 1.2 support is advertised??
2610 // We need to workaround...
2611
2612 #define FILLSZ 0x100000
2613
2614 char *tmp = (char *) mymalloc (FILLSZ);
2615
2616 for (uint i = 0; i < size; i += FILLSZ)
2617 {
2618 const int left = size - i;
2619
2620 const int fillsz = MIN (FILLSZ, left);
2621
2622 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2623 }
2624
2625 myfree (tmp);
2626 }
2627 }
2628
2629 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)
2630 {
2631 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2632 {
2633 if (attack_mode == ATTACK_MODE_BF)
2634 {
2635 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2636 {
2637 const uint size_tm = 32 * sizeof (bs_word_t);
2638
2639 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2640
2641 run_kernel_tm (device_param);
2642
2643 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);
2644 }
2645 }
2646
2647 if (highest_pw_len < 16)
2648 {
2649 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2650 }
2651 else if (highest_pw_len < 32)
2652 {
2653 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2654 }
2655 else
2656 {
2657 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2658 }
2659 }
2660 else
2661 {
2662 run_kernel_amp (device_param, pws_cnt);
2663
2664 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2665
2666 if (opts_type & OPTS_TYPE_HOOK12)
2667 {
2668 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2669 }
2670
2671 uint iter = salt_buf->salt_iter;
2672
2673 uint loop_step = device_param->kernel_loops;
2674
2675 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2676 {
2677 uint loop_left = iter - loop_pos;
2678
2679 loop_left = MIN (loop_left, loop_step);
2680
2681 device_param->kernel_params_buf32[25] = loop_pos;
2682 device_param->kernel_params_buf32[26] = loop_left;
2683
2684 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2685
2686 if (data.devices_status == STATUS_CRACKED) break;
2687 if (data.devices_status == STATUS_ABORTED) break;
2688 if (data.devices_status == STATUS_QUIT) break;
2689
2690 /**
2691 * speed
2692 */
2693
2694 const float iter_part = (float) (loop_pos + loop_left) / iter;
2695
2696 const u64 perf_sum_all = pws_cnt * iter_part;
2697
2698 double speed_ms;
2699
2700 hc_timer_get (device_param->timer_speed, speed_ms);
2701
2702 const u32 speed_pos = device_param->speed_pos;
2703
2704 device_param->speed_cnt[speed_pos] = perf_sum_all;
2705
2706 device_param->speed_ms[speed_pos] = speed_ms;
2707 }
2708
2709 if (opts_type & OPTS_TYPE_HOOK23)
2710 {
2711 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2712
2713 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);
2714
2715 // do something with data
2716
2717 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);
2718 }
2719
2720 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2721 }
2722 }
2723
2724 static int run_rule_engine (const int rule_len, const char *rule_buf)
2725 {
2726 if (rule_len == 0)
2727 {
2728 return 0;
2729 }
2730 else if (rule_len == 1)
2731 {
2732 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2733 }
2734
2735 return 1;
2736 }
2737
2738 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2739 {
2740 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2741 {
2742 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);
2743 }
2744 else if (data.attack_kern == ATTACK_KERN_COMBI)
2745 {
2746 if (data.attack_mode == ATTACK_MODE_HYBRID2)
2747 {
2748 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2749 {
2750 for (u32 i = 0; i < pws_cnt; i++)
2751 {
2752 const u32 pw_len = device_param->pws_buf[i].pw_len;
2753
2754 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2755
2756 ptr[pw_len] = 0x01;
2757 }
2758 }
2759 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
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] = 0x80;
2768 }
2769 }
2770 }
2771
2772 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);
2773 }
2774 else if (data.attack_kern == ATTACK_KERN_BF)
2775 {
2776 const u64 off = device_param->words_off;
2777
2778 device_param->kernel_params_mp_l_buf64[3] = off;
2779
2780 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2781 }
2782 }
2783
2784 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops, const int repeat)
2785 {
2786 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2787
2788 device_param->kernel_params_buf32[26] = kernel_loops;
2789 device_param->kernel_params_buf32[27] = kernel_loops;
2790
2791 // init some fake words
2792
2793 for (u32 i = 0; i < kernel_power; i++)
2794 {
2795 device_param->pws_buf[i].i[0] = i;
2796 device_param->pws_buf[i].i[1] = 0x01234567;
2797 device_param->pws_buf[i].pw_len = 4 + (i & 3);
2798 }
2799
2800 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, kernel_power * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2801
2802 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2803 {
2804 run_kernel_amp (device_param, kernel_power);
2805 }
2806
2807 // caching run
2808
2809 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2810 {
2811 run_kernel (KERN_RUN_1, device_param, kernel_power, false);
2812 }
2813 else
2814 {
2815 run_kernel (KERN_RUN_2, device_param, kernel_power, false);
2816 }
2817
2818 // now user repeats
2819
2820 for (int i = 0; i < repeat; i++)
2821 {
2822 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2823 {
2824 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2825 }
2826 else
2827 {
2828 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2829 }
2830 }
2831
2832 const double exec_ms_prev = get_avg_exec_time (device_param, repeat);
2833
2834 // reset fake words
2835
2836 memset (device_param->pws_buf, 0, kernel_power * sizeof (pw_t));
2837
2838 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, kernel_power * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2839 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_amp_buf, CL_TRUE, 0, kernel_power * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2840
2841 return exec_ms_prev;
2842 }
2843
2844 static void autotune (hc_device_param_t *device_param)
2845 {
2846 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2847
2848 const u32 kernel_accel_min = device_param->kernel_accel_min;
2849 const u32 kernel_accel_max = device_param->kernel_accel_max;
2850
2851 const u32 kernel_loops_min = device_param->kernel_loops_min;
2852 const u32 kernel_loops_max = device_param->kernel_loops_max;
2853
2854 u32 kernel_accel = kernel_accel_min;
2855 u32 kernel_loops = kernel_loops_min;
2856
2857 // steps
2858
2859 #define STEPS_CNT 10
2860
2861 #define STEPS_ACCEL_CNT (STEPS_CNT + 2)
2862 #define STEPS_LOOPS_CNT (STEPS_CNT + 2)
2863
2864 u32 steps_accel[STEPS_ACCEL_CNT];
2865 u32 steps_loops[STEPS_LOOPS_CNT];
2866
2867 for (int i = 0; i < STEPS_ACCEL_CNT; i++)
2868 {
2869 steps_accel[i] = 1 << i;
2870 }
2871
2872 for (int i = 0; i < STEPS_LOOPS_CNT; i++)
2873 {
2874 steps_loops[i] = 1 << i;
2875 }
2876
2877 steps_accel[STEPS_CNT + 0] = kernel_accel_min;
2878 steps_accel[STEPS_CNT + 1] = kernel_accel_max;
2879
2880 steps_loops[STEPS_CNT + 0] = kernel_loops_min;
2881 steps_loops[STEPS_CNT + 1] = kernel_loops_max;
2882
2883 qsort (steps_accel, STEPS_ACCEL_CNT, sizeof (u32), sort_by_u32);
2884 qsort (steps_loops, STEPS_LOOPS_CNT, sizeof (u32), sort_by_u32);
2885
2886 // find out highest kernel-loops that stays below target_ms, we can use it later for multiplication as this is a linear function
2887
2888 u32 kernel_loops_tmp;
2889
2890 for (kernel_loops_tmp = kernel_loops_max; kernel_loops_tmp > kernel_loops_min; kernel_loops_tmp >>= 1)
2891 {
2892 const double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops_tmp, 1);
2893
2894 if (exec_ms < target_ms) break;
2895 }
2896
2897 // kernel-accel
2898
2899 if (kernel_accel_min < kernel_accel_max)
2900 {
2901 double e_best = 0;
2902
2903 for (int i = 0; i < STEPS_ACCEL_CNT; i++)
2904 {
2905 const u32 kernel_accel_try = steps_accel[i];
2906
2907 if (kernel_accel_try < kernel_accel_min) continue;
2908 if (kernel_accel_try > kernel_accel_max) break;
2909
2910 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_tmp, 1);
2911
2912 if (exec_ms > target_ms) break;
2913
2914 const double e = kernel_accel_try / exec_ms;
2915
2916 if (e > e_best)
2917 {
2918 kernel_accel = kernel_accel_try;
2919
2920 e_best = e;
2921 }
2922 }
2923 }
2924
2925 // kernel-loops final
2926
2927 if (kernel_loops_min < kernel_loops_max)
2928 {
2929 double e_best = 0;
2930
2931 for (int i = 0; i < STEPS_LOOPS_CNT; i++)
2932 {
2933 const u32 kernel_loops_try = steps_loops[i];
2934
2935 if (kernel_loops_try < kernel_loops_min) continue;
2936 if (kernel_loops_try > kernel_loops_max) break;
2937
2938 const double exec_ms = try_run (device_param, kernel_accel, kernel_loops_try, 1);
2939
2940 if (exec_ms > target_ms) break;
2941
2942 const double e = kernel_loops_try / exec_ms;
2943
2944 if (e > e_best)
2945 {
2946 kernel_loops = kernel_loops_try;
2947
2948 e_best = e;
2949 }
2950 }
2951 }
2952
2953 // final balance
2954
2955 u32 kernel_accel_best = kernel_accel;
2956 u32 kernel_loops_best = kernel_loops;
2957
2958 u32 exec_best = -1;
2959
2960 if ((kernel_accel_min < kernel_accel_max) || (kernel_loops_min < kernel_loops_max))
2961 {
2962 const double exec_ms = try_run (device_param, kernel_accel_best, kernel_loops_best, 1);
2963
2964 exec_best = exec_ms;
2965 }
2966
2967 // reset
2968
2969 if (kernel_accel_min < kernel_accel_max)
2970 {
2971 u32 kernel_accel_try = kernel_accel;
2972 u32 kernel_loops_try = kernel_loops;
2973
2974 for (int i = 0; i < 2; i++)
2975 {
2976 kernel_accel_try >>= 1;
2977 kernel_loops_try <<= 1;
2978
2979 if (kernel_accel_try < kernel_accel_min) break;
2980 if (kernel_loops_try > kernel_loops_max) break;
2981
2982 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
2983
2984 if (exec_ms < exec_best)
2985 {
2986 kernel_accel_best = kernel_accel_try;
2987 kernel_loops_best = kernel_loops_try;
2988
2989 exec_best = exec_ms;
2990 }
2991 }
2992 }
2993
2994 // reset
2995
2996 if (kernel_loops_min < kernel_loops_max)
2997 {
2998 u32 kernel_accel_try = kernel_accel;
2999 u32 kernel_loops_try = kernel_loops;
3000
3001 for (int i = 0; i < 2; i++)
3002 {
3003 kernel_accel_try <<= 1;
3004 kernel_loops_try >>= 1;
3005
3006 if (kernel_accel_try > kernel_accel_max) break;
3007 if (kernel_loops_try < kernel_loops_min) break;
3008
3009 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
3010
3011 if (exec_ms < exec_best)
3012 {
3013 kernel_accel_best = kernel_accel_try;
3014 kernel_loops_best = kernel_loops_try;
3015
3016 exec_best = exec_ms;
3017 }
3018 }
3019 }
3020
3021 // reset timer
3022
3023 device_param->exec_pos = 0;
3024
3025 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3026
3027 // store
3028
3029 kernel_accel = kernel_accel_best;
3030 kernel_loops = kernel_loops_best;
3031
3032 device_param->kernel_accel = kernel_accel;
3033 device_param->kernel_loops = kernel_loops;
3034
3035 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3036
3037 device_param->kernel_power = kernel_power;
3038
3039 #ifdef DEBUG
3040
3041 if (data.quiet == 0)
3042 {
3043 clear_prompt ();
3044
3045 log_info ("Device #%u: autotuned kernel-accel to %u\n"
3046 "Device #%u: autotuned kernel-loops to %u\n",
3047 device_param->device_id + 1,
3048 kernel_accel,
3049 device_param->device_id + 1,
3050 kernel_loops);
3051
3052 fprintf (stdout, "%s", PROMPT);
3053 fflush (stdout);
3054 }
3055
3056 #endif
3057 }
3058
3059 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3060 {
3061 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3062
3063 // init speed timer
3064
3065 uint speed_pos = device_param->speed_pos;
3066
3067 #ifdef _POSIX
3068 if (device_param->timer_speed.tv_sec == 0)
3069 {
3070 hc_timer_set (&device_param->timer_speed);
3071 }
3072 #endif
3073
3074 #ifdef _WIN
3075 if (device_param->timer_speed.QuadPart == 0)
3076 {
3077 hc_timer_set (&device_param->timer_speed);
3078 }
3079 #endif
3080
3081 // find higest password length, this is for optimization stuff
3082
3083 uint highest_pw_len = 0;
3084
3085 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3086 {
3087 }
3088 else if (data.attack_kern == ATTACK_KERN_COMBI)
3089 {
3090 }
3091 else if (data.attack_kern == ATTACK_KERN_BF)
3092 {
3093 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3094 + device_param->kernel_params_mp_l_buf32[5];
3095 }
3096
3097 // iteration type
3098
3099 uint innerloop_step = 0;
3100 uint innerloop_cnt = 0;
3101
3102 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3103 else innerloop_step = 1;
3104
3105 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3106 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3107 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3108
3109 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3110
3111 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3112 {
3113 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3114
3115 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3116
3117 if (data.devices_status == STATUS_CRACKED) break;
3118 if (data.devices_status == STATUS_ABORTED) break;
3119 if (data.devices_status == STATUS_QUIT) break;
3120 if (data.devices_status == STATUS_BYPASS) break;
3121
3122 salt_t *salt_buf = &data.salts_buf[salt_pos];
3123
3124 device_param->kernel_params_buf32[24] = salt_pos;
3125 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3126 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3127
3128 FILE *combs_fp = device_param->combs_fp;
3129
3130 if (data.attack_mode == ATTACK_MODE_COMBI)
3131 {
3132 rewind (combs_fp);
3133 }
3134
3135 // innerloops
3136
3137 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3138 {
3139 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3140
3141 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3142
3143 if (data.devices_status == STATUS_CRACKED) break;
3144 if (data.devices_status == STATUS_ABORTED) break;
3145 if (data.devices_status == STATUS_QUIT) break;
3146 if (data.devices_status == STATUS_BYPASS) break;
3147
3148 uint innerloop_left = innerloop_cnt - innerloop_pos;
3149
3150 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3151
3152 device_param->innerloop_pos = innerloop_pos;
3153 device_param->innerloop_left = innerloop_left;
3154
3155 device_param->kernel_params_buf32[27] = innerloop_left;
3156
3157 // i think we can get rid of this
3158 if (innerloop_left == 0)
3159 {
3160 puts ("bug, how should this happen????\n");
3161
3162 continue;
3163 }
3164
3165 if (data.salts_shown[salt_pos] == 1)
3166 {
3167 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3168
3169 continue;
3170 }
3171
3172 // initialize amplifiers
3173
3174 if (data.attack_mode == ATTACK_MODE_COMBI)
3175 {
3176 uint i = 0;
3177
3178 while (i < innerloop_left)
3179 {
3180 if (feof (combs_fp)) break;
3181
3182 int line_len = fgetl (combs_fp, line_buf);
3183
3184 if (line_len >= PW_MAX1) continue;
3185
3186 line_len = convert_from_hex (line_buf, line_len);
3187
3188 char *line_buf_new = line_buf;
3189
3190 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3191 {
3192 char rule_buf_out[BLOCK_SIZE] = { 0 };
3193
3194 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3195
3196 if (rule_len_out < 0)
3197 {
3198 data.words_progress_rejected[salt_pos] += pws_cnt;
3199
3200 continue;
3201 }
3202
3203 line_len = rule_len_out;
3204
3205 line_buf_new = rule_buf_out;
3206 }
3207
3208 line_len = MIN (line_len, PW_DICTMAX);
3209
3210 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3211
3212 memcpy (ptr, line_buf_new, line_len);
3213
3214 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3215
3216 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3217 {
3218 uppercase (ptr, line_len);
3219 }
3220
3221 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3222 {
3223 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3224 {
3225 ptr[line_len] = 0x80;
3226 }
3227
3228 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3229 {
3230 ptr[line_len] = 0x01;
3231 }
3232 }
3233
3234 device_param->combs_buf[i].pw_len = line_len;
3235
3236 i++;
3237 }
3238
3239 for (uint j = i; j < innerloop_left; j++)
3240 {
3241 device_param->combs_buf[j].i[0] = 0;
3242 device_param->combs_buf[j].i[1] = 0;
3243 device_param->combs_buf[j].i[2] = 0;
3244 device_param->combs_buf[j].i[3] = 0;
3245 device_param->combs_buf[j].i[4] = 0;
3246 device_param->combs_buf[j].i[5] = 0;
3247 device_param->combs_buf[j].i[6] = 0;
3248 device_param->combs_buf[j].i[7] = 0;
3249
3250 device_param->combs_buf[j].pw_len = 0;
3251 }
3252
3253 innerloop_left = i;
3254 }
3255 else if (data.attack_mode == ATTACK_MODE_BF)
3256 {
3257 u64 off = innerloop_pos;
3258
3259 device_param->kernel_params_mp_r_buf64[3] = off;
3260
3261 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3262 }
3263 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3264 {
3265 u64 off = innerloop_pos;
3266
3267 device_param->kernel_params_mp_buf64[3] = off;
3268
3269 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3270 }
3271 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3272 {
3273 u64 off = innerloop_pos;
3274
3275 device_param->kernel_params_mp_buf64[3] = off;
3276
3277 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3278 }
3279
3280 // copy amplifiers
3281
3282 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3283 {
3284 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);
3285 }
3286 else if (data.attack_mode == ATTACK_MODE_COMBI)
3287 {
3288 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);
3289 }
3290 else if (data.attack_mode == ATTACK_MODE_BF)
3291 {
3292 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);
3293 }
3294 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3295 {
3296 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);
3297 }
3298 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3299 {
3300 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);
3301 }
3302
3303 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3304
3305 if (data.benchmark == 1)
3306 {
3307 double exec_ms_avg_prev = get_avg_exec_time (device_param, EXEC_CACHE);
3308
3309 // a few caching rounds
3310
3311 for (u32 i = 0; i < 2; i++)
3312 {
3313 hc_timer_set (&device_param->timer_speed);
3314
3315 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3316
3317 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
3318
3319 exec_ms_avg_prev = exec_ms_avg;
3320 }
3321
3322 // benchmark_repeats became a maximum possible repeats
3323
3324 for (u32 i = 2; i < data.benchmark_repeats; i++)
3325 {
3326 hc_timer_set (&device_param->timer_speed);
3327
3328 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3329
3330 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
3331
3332 if ((exec_ms_avg_prev / exec_ms_avg) < 1.001) break;
3333
3334 exec_ms_avg_prev = exec_ms_avg;
3335 }
3336 }
3337
3338 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3339
3340 if (data.devices_status == STATUS_CRACKED) break;
3341 if (data.devices_status == STATUS_ABORTED) break;
3342 if (data.devices_status == STATUS_QUIT) break;
3343
3344 /**
3345 * result
3346 */
3347
3348 hc_thread_mutex_lock (mux_display);
3349
3350 check_cracked (device_param, salt_pos);
3351
3352 hc_thread_mutex_unlock (mux_display);
3353
3354 /**
3355 * progress
3356 */
3357
3358 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3359
3360 hc_thread_mutex_lock (mux_counter);
3361
3362 data.words_progress_done[salt_pos] += perf_sum_all;
3363
3364 hc_thread_mutex_unlock (mux_counter);
3365
3366 /**
3367 * speed
3368 */
3369
3370 double speed_ms;
3371
3372 hc_timer_get (device_param->timer_speed, speed_ms);
3373
3374 hc_timer_set (&device_param->timer_speed);
3375
3376 hc_thread_mutex_lock (mux_display);
3377
3378 // current speed
3379
3380 device_param->speed_cnt[speed_pos] = perf_sum_all;
3381
3382 device_param->speed_ms[speed_pos] = speed_ms;
3383
3384 hc_thread_mutex_unlock (mux_display);
3385
3386 speed_pos++;
3387
3388 if (speed_pos == SPEED_CACHE)
3389 {
3390 speed_pos = 0;
3391 }
3392
3393 /**
3394 * benchmark
3395 */
3396
3397 if (data.benchmark == 1) break;
3398 }
3399 }
3400
3401 device_param->speed_pos = speed_pos;
3402
3403 myfree (line_buf);
3404 }
3405
3406 static void load_segment (wl_data_t *wl_data, FILE *fd)
3407 {
3408 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3409
3410 wl_data->pos = 0;
3411
3412 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3413
3414 wl_data->buf[wl_data->cnt] = 0;
3415
3416 if (wl_data->cnt == 0) return;
3417
3418 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3419
3420 while (!feof (fd))
3421 {
3422 if (wl_data->cnt == wl_data->avail)
3423 {
3424 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3425
3426 wl_data->avail += wl_data->incr;
3427 }
3428
3429 const int c = fgetc (fd);
3430
3431 if (c == EOF) break;
3432
3433 wl_data->buf[wl_data->cnt] = (char) c;
3434
3435 wl_data->cnt++;
3436
3437 if (c == '\n') break;
3438 }
3439
3440 // ensure stream ends with a newline
3441
3442 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3443 {
3444 wl_data->cnt++;
3445
3446 wl_data->buf[wl_data->cnt - 1] = '\n';
3447 }
3448
3449 return;
3450 }
3451
3452 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3453 {
3454 char *ptr = buf;
3455
3456 for (u32 i = 0; i < sz; i++, ptr++)
3457 {
3458 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3459
3460 if (i == 7)
3461 {
3462 *off = i;
3463 *len = i;
3464
3465 return;
3466 }
3467
3468 if (*ptr != '\n') continue;
3469
3470 *off = i + 1;
3471
3472 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3473
3474 *len = i;
3475
3476 return;
3477 }
3478
3479 *off = sz;
3480 *len = sz;
3481 }
3482
3483 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3484 {
3485 char *ptr = buf;
3486
3487 for (u32 i = 0; i < sz; i++, ptr++)
3488 {
3489 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3490
3491 if (*ptr != '\n') continue;
3492
3493 *off = i + 1;
3494
3495 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3496
3497 *len = i;
3498
3499 return;
3500 }
3501
3502 *off = sz;
3503 *len = sz;
3504 }
3505
3506 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3507 {
3508 char *ptr = buf;
3509
3510 for (u32 i = 0; i < sz; i++, ptr++)
3511 {
3512 if (*ptr != '\n') continue;
3513
3514 *off = i + 1;
3515
3516 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3517
3518 *len = i;
3519
3520 return;
3521 }
3522
3523 *off = sz;
3524 *len = sz;
3525 }
3526
3527 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3528 {
3529 while (wl_data->pos < wl_data->cnt)
3530 {
3531 uint off;
3532 uint len;
3533
3534 char *ptr = wl_data->buf + wl_data->pos;
3535
3536 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3537
3538 wl_data->pos += off;
3539
3540 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3541 {
3542 char rule_buf_out[BLOCK_SIZE] = { 0 };
3543
3544 int rule_len_out = -1;
3545
3546 if (len < BLOCK_SIZE)
3547 {
3548 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3549 }
3550
3551 if (rule_len_out < 0)
3552 {
3553 continue;
3554 }
3555
3556 if (rule_len_out > PW_MAX)
3557 {
3558 continue;
3559 }
3560 }
3561 else
3562 {
3563 if (len > PW_MAX)
3564 {
3565 continue;
3566 }
3567 }
3568
3569 *out_buf = ptr;
3570 *out_len = len;
3571
3572 return;
3573 }
3574
3575 if (feof (fd))
3576 {
3577 fprintf (stderr, "BUG feof()!!\n");
3578
3579 return;
3580 }
3581
3582 load_segment (wl_data, fd);
3583
3584 get_next_word (wl_data, fd, out_buf, out_len);
3585 }
3586
3587 #ifdef _POSIX
3588 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3589 #endif
3590
3591 #ifdef _WIN
3592 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3593 #endif
3594 {
3595 hc_signal (NULL);
3596
3597 dictstat_t d;
3598
3599 d.cnt = 0;
3600
3601 #ifdef _POSIX
3602 fstat (fileno (fd), &d.stat);
3603 #endif
3604
3605 #ifdef _WIN
3606 _fstat64 (fileno (fd), &d.stat);
3607 #endif
3608
3609 d.stat.st_mode = 0;
3610 d.stat.st_nlink = 0;
3611 d.stat.st_uid = 0;
3612 d.stat.st_gid = 0;
3613 d.stat.st_rdev = 0;
3614 d.stat.st_atime = 0;
3615
3616 #ifdef _POSIX
3617 d.stat.st_blksize = 0;
3618 d.stat.st_blocks = 0;
3619 #endif
3620
3621 if (d.stat.st_size == 0) return 0;
3622
3623 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3624
3625 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3626 {
3627 if (d_cache)
3628 {
3629 u64 cnt = d_cache->cnt;
3630
3631 u64 keyspace = cnt;
3632
3633 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3634 {
3635 keyspace *= data.kernel_rules_cnt;
3636 }
3637 else if (data.attack_kern == ATTACK_KERN_COMBI)
3638 {
3639 keyspace *= data.combs_cnt;
3640 }
3641
3642 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);
3643 if (data.quiet == 0) log_info ("");
3644
3645 hc_signal (sigHandler_default);
3646
3647 return (keyspace);
3648 }
3649 }
3650
3651 time_t now = 0;
3652 time_t prev = 0;
3653
3654 u64 comp = 0;
3655 u64 cnt = 0;
3656 u64 cnt2 = 0;
3657
3658 while (!feof (fd))
3659 {
3660 load_segment (wl_data, fd);
3661
3662 comp += wl_data->cnt;
3663
3664 u32 i = 0;
3665
3666 while (i < wl_data->cnt)
3667 {
3668 u32 len;
3669 u32 off;
3670
3671 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3672
3673 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3674 {
3675 char rule_buf_out[BLOCK_SIZE] = { 0 };
3676
3677 int rule_len_out = -1;
3678
3679 if (len < BLOCK_SIZE)
3680 {
3681 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3682 }
3683
3684 if (rule_len_out < 0)
3685 {
3686 len = PW_MAX1;
3687 }
3688 else
3689 {
3690 len = rule_len_out;
3691 }
3692 }
3693
3694 if (len < PW_MAX1)
3695 {
3696 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3697 {
3698 cnt += data.kernel_rules_cnt;
3699 }
3700 else if (data.attack_kern == ATTACK_KERN_COMBI)
3701 {
3702 cnt += data.combs_cnt;
3703 }
3704
3705 d.cnt++;
3706 }
3707
3708 i += off;
3709
3710 cnt2++;
3711 }
3712
3713 time (&now);
3714
3715 if ((now - prev) == 0) continue;
3716
3717 float percent = (float) comp / (float) d.stat.st_size;
3718
3719 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);
3720
3721 time (&prev);
3722 }
3723
3724 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);
3725 if (data.quiet == 0) log_info ("");
3726
3727 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3728
3729 hc_signal (sigHandler_default);
3730
3731 return (cnt);
3732 }
3733
3734 static void *thread_monitor (void *p)
3735 {
3736 uint runtime_check = 0;
3737 uint remove_check = 0;
3738 uint status_check = 0;
3739 uint restore_check = 0;
3740
3741 uint restore_left = data.restore_timer;
3742 uint remove_left = data.remove_timer;
3743 uint status_left = data.status_timer;
3744
3745 #ifdef HAVE_HWMON
3746 uint hwmon_check = 0;
3747
3748 // these variables are mainly used for fan control (AMD only)
3749
3750 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3751
3752 // temperature controller "loopback" values
3753
3754 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3755 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3756
3757 #ifdef HAVE_ADL
3758 int temp_threshold = 1; // degrees celcius
3759
3760 int fan_speed_min = 15; // in percentage
3761 int fan_speed_max = 100;
3762 #endif // HAVE_ADL
3763
3764 time_t last_temp_check_time;
3765 #endif // HAVE_HWMON
3766
3767 uint sleep_time = 1;
3768
3769 if (data.runtime)
3770 {
3771 runtime_check = 1;
3772 }
3773
3774 if (data.restore_timer)
3775 {
3776 restore_check = 1;
3777 }
3778
3779 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3780 {
3781 remove_check = 1;
3782 }
3783
3784 if (data.status == 1)
3785 {
3786 status_check = 1;
3787 }
3788
3789 #ifdef HAVE_HWMON
3790 if (data.gpu_temp_disable == 0)
3791 {
3792 time (&last_temp_check_time);
3793
3794 hwmon_check = 1;
3795 }
3796 #endif
3797
3798 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3799 {
3800 #ifdef HAVE_HWMON
3801 if (hwmon_check == 0)
3802 #endif
3803 return (p);
3804 }
3805
3806 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3807 {
3808 hc_sleep (sleep_time);
3809
3810 if (data.devices_status != STATUS_RUNNING) continue;
3811
3812 #ifdef HAVE_HWMON
3813 if (hwmon_check == 1)
3814 {
3815 hc_thread_mutex_lock (mux_adl);
3816
3817 time_t temp_check_time;
3818
3819 time (&temp_check_time);
3820
3821 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3822
3823 if (Ta == 0) Ta = 1;
3824
3825 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3826 {
3827 hc_device_param_t *device_param = &data.devices_param[device_id];
3828
3829 if (device_param->skipped) continue;
3830
3831 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3832
3833 const int temperature = hm_get_temperature_with_device_id (device_id);
3834
3835 if (temperature > (int) data.gpu_temp_abort)
3836 {
3837 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3838
3839 if (data.devices_status != STATUS_QUIT) myabort ();
3840
3841 break;
3842 }
3843
3844 #ifdef HAVE_ADL
3845 const int gpu_temp_retain = data.gpu_temp_retain;
3846
3847 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3848 {
3849 if (data.hm_device[device_id].fan_supported == 1)
3850 {
3851 int temp_cur = temperature;
3852
3853 int temp_diff_new = gpu_temp_retain - temp_cur;
3854
3855 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3856
3857 // calculate Ta value (time difference in seconds between the last check and this check)
3858
3859 last_temp_check_time = temp_check_time;
3860
3861 float Kp = 1.8;
3862 float Ki = 0.005;
3863 float Kd = 6;
3864
3865 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3866
3867 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);
3868
3869 if (abs (fan_diff_required) >= temp_threshold)
3870 {
3871 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3872
3873 int fan_speed_level = fan_speed_cur;
3874
3875 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3876
3877 int fan_speed_new = fan_speed_level - fan_diff_required;
3878
3879 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3880 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3881
3882 if (fan_speed_new != fan_speed_cur)
3883 {
3884 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3885 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3886
3887 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3888 {
3889 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3890
3891 fan_speed_chgd[device_id] = 1;
3892 }
3893
3894 temp_diff_old[device_id] = temp_diff_new;
3895 }
3896 }
3897 }
3898 }
3899 #endif // HAVE_ADL
3900 }
3901
3902 hc_thread_mutex_unlock (mux_adl);
3903 }
3904 #endif // HAVE_HWMON
3905
3906 if (restore_check == 1)
3907 {
3908 restore_left--;
3909
3910 if (restore_left == 0)
3911 {
3912 if (data.restore_disable == 0) cycle_restore ();
3913
3914 restore_left = data.restore_timer;
3915 }
3916 }
3917
3918 if ((runtime_check == 1) && (data.runtime_start > 0))
3919 {
3920 time_t runtime_cur;
3921
3922 time (&runtime_cur);
3923
3924 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3925
3926 if (runtime_left <= 0)
3927 {
3928 if (data.benchmark == 0)
3929 {
3930 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3931 }
3932
3933 if (data.devices_status != STATUS_QUIT) myabort ();
3934 }
3935 }
3936
3937 if (remove_check == 1)
3938 {
3939 remove_left--;
3940
3941 if (remove_left == 0)
3942 {
3943 if (data.digests_saved != data.digests_done)
3944 {
3945 data.digests_saved = data.digests_done;
3946
3947 save_hash ();
3948 }
3949
3950 remove_left = data.remove_timer;
3951 }
3952 }
3953
3954 if (status_check == 1)
3955 {
3956 status_left--;
3957
3958 if (status_left == 0)
3959 {
3960 hc_thread_mutex_lock (mux_display);
3961
3962 if (data.quiet == 0) clear_prompt ();
3963
3964 if (data.quiet == 0) log_info ("");
3965
3966 status_display ();
3967
3968 if (data.quiet == 0) log_info ("");
3969
3970 hc_thread_mutex_unlock (mux_display);
3971
3972 status_left = data.status_timer;
3973 }
3974 }
3975 }
3976
3977 #ifdef HAVE_HWMON
3978 myfree (fan_speed_chgd);
3979
3980 myfree (temp_diff_old);
3981 myfree (temp_diff_sum);
3982 #endif
3983
3984 p = NULL;
3985
3986 return (p);
3987 }
3988
3989 static void *thread_outfile_remove (void *p)
3990 {
3991 // some hash-dependent constants
3992 char *outfile_dir = data.outfile_check_directory;
3993 uint dgst_size = data.dgst_size;
3994 uint isSalted = data.isSalted;
3995 uint esalt_size = data.esalt_size;
3996 uint hash_mode = data.hash_mode;
3997
3998 uint outfile_check_timer = data.outfile_check_timer;
3999
4000 char separator = data.separator;
4001
4002 // some hash-dependent functions
4003 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4004 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4005
4006 // buffers
4007 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4008
4009 hash_buf.digest = mymalloc (dgst_size);
4010
4011 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4012
4013 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4014
4015 uint digest_buf[64] = { 0 };
4016
4017 outfile_data_t *out_info = NULL;
4018
4019 char **out_files = NULL;
4020
4021 time_t folder_mtime = 0;
4022
4023 int out_cnt = 0;
4024
4025 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4026
4027 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4028 {
4029 hc_sleep (1);
4030
4031 if (data.devices_status != STATUS_RUNNING) continue;
4032
4033 check_left--;
4034
4035 if (check_left == 0)
4036 {
4037 struct stat outfile_check_stat;
4038
4039 if (stat (outfile_dir, &outfile_check_stat) == 0)
4040 {
4041 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4042
4043 if (is_dir == 1)
4044 {
4045 if (outfile_check_stat.st_mtime > folder_mtime)
4046 {
4047 char **out_files_new = scan_directory (outfile_dir);
4048
4049 int out_cnt_new = count_dictionaries (out_files_new);
4050
4051 outfile_data_t *out_info_new = NULL;
4052
4053 if (out_cnt_new > 0)
4054 {
4055 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4056
4057 for (int i = 0; i < out_cnt_new; i++)
4058 {
4059 out_info_new[i].file_name = out_files_new[i];
4060
4061 // check if there are files that we have seen/checked before (and not changed)
4062
4063 for (int j = 0; j < out_cnt; j++)
4064 {
4065 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4066 {
4067 struct stat outfile_stat;
4068
4069 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4070 {
4071 if (outfile_stat.st_ctime == out_info[j].ctime)
4072 {
4073 out_info_new[i].ctime = out_info[j].ctime;
4074 out_info_new[i].seek = out_info[j].seek;
4075 }
4076 }
4077 }
4078 }
4079 }
4080 }
4081
4082 local_free (out_info);
4083 local_free (out_files);
4084
4085 out_files = out_files_new;
4086 out_cnt = out_cnt_new;
4087 out_info = out_info_new;
4088
4089 folder_mtime = outfile_check_stat.st_mtime;
4090 }
4091
4092 for (int j = 0; j < out_cnt; j++)
4093 {
4094 FILE *fp = fopen (out_info[j].file_name, "rb");
4095
4096 if (fp != NULL)
4097 {
4098 //hc_thread_mutex_lock (mux_display);
4099
4100 #ifdef _POSIX
4101 struct stat outfile_stat;
4102
4103 fstat (fileno (fp), &outfile_stat);
4104 #endif
4105
4106 #ifdef _WIN
4107 struct stat64 outfile_stat;
4108
4109 _fstat64 (fileno (fp), &outfile_stat);
4110 #endif
4111
4112 if (outfile_stat.st_ctime > out_info[j].ctime)
4113 {
4114 out_info[j].ctime = outfile_stat.st_ctime;
4115 out_info[j].seek = 0;
4116 }
4117
4118 fseek (fp, out_info[j].seek, SEEK_SET);
4119
4120 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4121
4122 while (!feof (fp))
4123 {
4124 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4125
4126 if (ptr == NULL) break;
4127
4128 int line_len = strlen (line_buf);
4129
4130 if (line_len <= 0) continue;
4131
4132 int iter = MAX_CUT_TRIES;
4133
4134 for (uint i = line_len - 1; i && iter; i--, line_len--)
4135 {
4136 if (line_buf[i] != separator) continue;
4137
4138 int parser_status = PARSER_OK;
4139
4140 if ((hash_mode != 2500) && (hash_mode != 6800))
4141 {
4142 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4143 }
4144
4145 uint found = 0;
4146
4147 if (parser_status == PARSER_OK)
4148 {
4149 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4150 {
4151 if (data.salts_shown[salt_pos] == 1) continue;
4152
4153 salt_t *salt_buf = &data.salts_buf[salt_pos];
4154
4155 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4156 {
4157 uint idx = salt_buf->digests_offset + digest_pos;
4158
4159 if (data.digests_shown[idx] == 1) continue;
4160
4161 uint cracked = 0;
4162
4163 if (hash_mode == 6800)
4164 {
4165 if (i == salt_buf->salt_len)
4166 {
4167 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4168 }
4169 }
4170 else if (hash_mode == 2500)
4171 {
4172 // BSSID : MAC1 : MAC2 (:plain)
4173 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4174 {
4175 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4176
4177 if (!cracked) continue;
4178
4179 // now compare MAC1 and MAC2 too, since we have this additional info
4180 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4181 char *mac2_pos = mac1_pos + 12 + 1;
4182
4183 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4184 wpa_t *wpa = &wpas[salt_pos];
4185
4186 // compare hex string(s) vs binary MAC address(es)
4187
4188 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4189 {
4190 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4191 {
4192 cracked = 0;
4193
4194 break;
4195 }
4196 }
4197
4198 // early skip ;)
4199 if (!cracked) continue;
4200
4201 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4202 {
4203 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4204 {
4205 cracked = 0;
4206
4207 break;
4208 }
4209 }
4210 }
4211 }
4212 else
4213 {
4214 char *digests_buf_ptr = (char *) data.digests_buf;
4215
4216 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4217
4218 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4219 }
4220
4221 if (cracked == 1)
4222 {
4223 found = 1;
4224
4225 data.digests_shown[idx] = 1;
4226
4227 data.digests_done++;
4228
4229 salt_buf->digests_done++;
4230
4231 if (salt_buf->digests_done == salt_buf->digests_cnt)
4232 {
4233 data.salts_shown[salt_pos] = 1;
4234
4235 data.salts_done++;
4236
4237 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4238 }
4239 }
4240 }
4241
4242 if (data.devices_status == STATUS_CRACKED) break;
4243 }
4244 }
4245
4246 if (found) break;
4247
4248 if (data.devices_status == STATUS_CRACKED) break;
4249
4250 iter--;
4251 }
4252
4253 if (data.devices_status == STATUS_CRACKED) break;
4254 }
4255
4256 myfree (line_buf);
4257
4258 out_info[j].seek = ftell (fp);
4259
4260 //hc_thread_mutex_unlock (mux_display);
4261
4262 fclose (fp);
4263 }
4264 }
4265 }
4266 }
4267
4268 check_left = outfile_check_timer;
4269 }
4270 }
4271
4272 if (esalt_size) local_free (hash_buf.esalt);
4273
4274 if (isSalted) local_free (hash_buf.salt);
4275
4276 local_free (hash_buf.digest);
4277
4278 local_free (out_info);
4279
4280 local_free (out_files);
4281
4282 p = NULL;
4283
4284 return (p);
4285 }
4286
4287 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4288 {
4289 if (device_param->pws_cnt < device_param->kernel_power)
4290 {
4291 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4292
4293 u8 *ptr = (u8 *) pw->i;
4294
4295 memcpy (ptr, pw_buf, pw_len);
4296
4297 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4298
4299 pw->pw_len = pw_len;
4300
4301 device_param->pws_cnt++;
4302 }
4303 else
4304 {
4305 fprintf (stderr, "BUG pw_add()!!\n");
4306
4307 return;
4308 }
4309 }
4310
4311 static uint get_work (hc_device_param_t *device_param, const u64 max, const bool allow_div)
4312 {
4313 hc_thread_mutex_lock (mux_dispatcher);
4314
4315 const u64 words_cur = data.words_cur;
4316 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4317
4318 device_param->words_off = words_cur;
4319
4320 const u64 words_left = words_base - words_cur;
4321
4322 if (allow_div)
4323 {
4324 if (data.kernel_power_all > words_left)
4325 {
4326 if (data.kernel_power_div == 0)
4327 {
4328 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4329 }
4330 }
4331
4332 if (data.kernel_power_div)
4333 {
4334 if (device_param->kernel_power == device_param->kernel_power_user)
4335 {
4336 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4337
4338 if (kernel_power_new < device_param->kernel_power)
4339 {
4340 device_param->kernel_power = kernel_power_new;
4341 }
4342 }
4343 }
4344 }
4345
4346 const uint kernel_power = device_param->kernel_power;
4347
4348 uint work = MIN (words_left, kernel_power);
4349
4350 work = MIN (work, max);
4351
4352 data.words_cur += work;
4353
4354 hc_thread_mutex_unlock (mux_dispatcher);
4355
4356 return work;
4357 }
4358
4359 static void *thread_calc_stdin (void *p)
4360 {
4361 hc_device_param_t *device_param = (hc_device_param_t *) p;
4362
4363 if (device_param->skipped) return NULL;
4364
4365 autotune (device_param);
4366
4367 char *buf = (char *) mymalloc (HCBUFSIZ);
4368
4369 const uint attack_kern = data.attack_kern;
4370
4371 const uint kernel_power = device_param->kernel_power;
4372
4373 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4374 {
4375 hc_thread_mutex_lock (mux_dispatcher);
4376
4377 if (feof (stdin) != 0)
4378 {
4379 hc_thread_mutex_unlock (mux_dispatcher);
4380
4381 break;
4382 }
4383
4384 uint words_cur = 0;
4385
4386 while (words_cur < kernel_power)
4387 {
4388 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4389
4390 if (line_buf == NULL) break;
4391
4392 uint line_len = in_superchop (line_buf);
4393
4394 line_len = convert_from_hex (line_buf, line_len);
4395
4396 // post-process rule engine
4397
4398 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4399 {
4400 char rule_buf_out[BLOCK_SIZE] = { 0 };
4401
4402 int rule_len_out = -1;
4403
4404 if (line_len < BLOCK_SIZE)
4405 {
4406 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4407 }
4408
4409 if (rule_len_out < 0) continue;
4410
4411 line_buf = rule_buf_out;
4412 line_len = rule_len_out;
4413 }
4414
4415 if (line_len > PW_MAX)
4416 {
4417 continue;
4418 }
4419
4420 if (attack_kern == ATTACK_KERN_STRAIGHT)
4421 {
4422 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4423 {
4424 hc_thread_mutex_lock (mux_counter);
4425
4426 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4427 {
4428 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4429 }
4430
4431 hc_thread_mutex_unlock (mux_counter);
4432
4433 continue;
4434 }
4435 }
4436 else if (attack_kern == ATTACK_KERN_COMBI)
4437 {
4438 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4439 // since we still need to combine the plains
4440
4441 if (line_len > data.pw_max)
4442 {
4443 hc_thread_mutex_lock (mux_counter);
4444
4445 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4446 {
4447 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4448 }
4449
4450 hc_thread_mutex_unlock (mux_counter);
4451
4452 continue;
4453 }
4454 }
4455
4456 pw_add (device_param, (u8 *) line_buf, line_len);
4457
4458 words_cur++;
4459
4460 if (data.devices_status == STATUS_CRACKED) break;
4461 if (data.devices_status == STATUS_ABORTED) break;
4462 if (data.devices_status == STATUS_QUIT) break;
4463 if (data.devices_status == STATUS_BYPASS) break;
4464 }
4465
4466 hc_thread_mutex_unlock (mux_dispatcher);
4467
4468 if (data.devices_status == STATUS_CRACKED) break;
4469 if (data.devices_status == STATUS_ABORTED) break;
4470 if (data.devices_status == STATUS_QUIT) break;
4471 if (data.devices_status == STATUS_BYPASS) break;
4472
4473 // flush
4474
4475 const uint pws_cnt = device_param->pws_cnt;
4476
4477 if (pws_cnt)
4478 {
4479 run_copy (device_param, pws_cnt);
4480
4481 run_cracker (device_param, pws_cnt);
4482
4483 device_param->pws_cnt = 0;
4484
4485 if (attack_kern == ATTACK_KERN_STRAIGHT)
4486 {
4487 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4488 }
4489 else if (attack_kern == ATTACK_KERN_COMBI)
4490 {
4491 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4492 }
4493 }
4494 }
4495
4496 device_param->kernel_accel = 0;
4497 device_param->kernel_loops = 0;
4498
4499 myfree (buf);
4500
4501 return NULL;
4502 }
4503
4504 static void *thread_calc (void *p)
4505 {
4506 hc_device_param_t *device_param = (hc_device_param_t *) p;
4507
4508 if (device_param->skipped) return NULL;
4509
4510 autotune (device_param);
4511
4512 const uint attack_mode = data.attack_mode;
4513 const uint attack_kern = data.attack_kern;
4514
4515 if (attack_mode == ATTACK_MODE_BF)
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 const uint work = get_work (device_param, -1, true);
4520
4521 if (work == 0) break;
4522
4523 const u64 words_off = device_param->words_off;
4524 const u64 words_fin = words_off + work;
4525
4526 const uint pws_cnt = work;
4527
4528 device_param->pws_cnt = pws_cnt;
4529
4530 if (pws_cnt)
4531 {
4532 run_copy (device_param, pws_cnt);
4533
4534 run_cracker (device_param, pws_cnt);
4535
4536 device_param->pws_cnt = 0;
4537
4538 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4539 }
4540
4541 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4542
4543 if (data.devices_status == STATUS_CRACKED) break;
4544 if (data.devices_status == STATUS_ABORTED) break;
4545 if (data.devices_status == STATUS_QUIT) break;
4546 if (data.devices_status == STATUS_BYPASS) break;
4547
4548 if (data.benchmark == 1) break;
4549
4550 device_param->words_done = words_fin;
4551 }
4552 }
4553 else
4554 {
4555 const uint segment_size = data.segment_size;
4556
4557 char *dictfile = data.dictfile;
4558
4559 if (attack_mode == ATTACK_MODE_COMBI)
4560 {
4561 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4562 {
4563 dictfile = data.dictfile2;
4564 }
4565 }
4566
4567 FILE *fd = fopen (dictfile, "rb");
4568
4569 if (fd == NULL)
4570 {
4571 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4572
4573 return NULL;
4574 }
4575
4576 if (attack_mode == ATTACK_MODE_COMBI)
4577 {
4578 const uint combs_mode = data.combs_mode;
4579
4580 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4581 {
4582 const char *dictfilec = data.dictfile2;
4583
4584 FILE *combs_fp = fopen (dictfilec, "rb");
4585
4586 if (combs_fp == NULL)
4587 {
4588 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4589
4590 fclose (fd);
4591
4592 return NULL;
4593 }
4594
4595 device_param->combs_fp = combs_fp;
4596 }
4597 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4598 {
4599 const char *dictfilec = data.dictfile;
4600
4601 FILE *combs_fp = fopen (dictfilec, "rb");
4602
4603 if (combs_fp == NULL)
4604 {
4605 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4606
4607 fclose (fd);
4608
4609 return NULL;
4610 }
4611
4612 device_param->combs_fp = combs_fp;
4613 }
4614 }
4615
4616 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4617
4618 wl_data->buf = (char *) mymalloc (segment_size);
4619 wl_data->avail = segment_size;
4620 wl_data->incr = segment_size;
4621 wl_data->cnt = 0;
4622 wl_data->pos = 0;
4623
4624 u64 words_cur = 0;
4625
4626 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4627 {
4628 u64 words_off = 0;
4629 u64 words_fin = 0;
4630
4631 bool allow_div = true;
4632
4633 u64 max = -1;
4634
4635 while (max)
4636 {
4637 const uint work = get_work (device_param, max, allow_div);
4638
4639 allow_div = false;
4640
4641 if (work == 0) break;
4642
4643 words_off = device_param->words_off;
4644 words_fin = words_off + work;
4645
4646 char *line_buf;
4647 uint line_len;
4648
4649 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4650
4651 max = 0;
4652
4653 for ( ; words_cur < words_fin; words_cur++)
4654 {
4655 get_next_word (wl_data, fd, &line_buf, &line_len);
4656
4657 line_len = convert_from_hex (line_buf, line_len);
4658
4659 // post-process rule engine
4660
4661 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4662 {
4663 char rule_buf_out[BLOCK_SIZE] = { 0 };
4664
4665 int rule_len_out = -1;
4666
4667 if (line_len < BLOCK_SIZE)
4668 {
4669 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4670 }
4671
4672 if (rule_len_out < 0) continue;
4673
4674 line_buf = rule_buf_out;
4675 line_len = rule_len_out;
4676 }
4677
4678 if (attack_kern == ATTACK_KERN_STRAIGHT)
4679 {
4680 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4681 {
4682 max++;
4683
4684 hc_thread_mutex_lock (mux_counter);
4685
4686 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4687 {
4688 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4689 }
4690
4691 hc_thread_mutex_unlock (mux_counter);
4692
4693 continue;
4694 }
4695 }
4696 else if (attack_kern == ATTACK_KERN_COMBI)
4697 {
4698 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4699 // since we still need to combine the plains
4700
4701 if (line_len > data.pw_max)
4702 {
4703 max++;
4704
4705 hc_thread_mutex_lock (mux_counter);
4706
4707 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4708 {
4709 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4710 }
4711
4712 hc_thread_mutex_unlock (mux_counter);
4713
4714 continue;
4715 }
4716 }
4717
4718 pw_add (device_param, (u8 *) line_buf, line_len);
4719
4720 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4721
4722 if (data.devices_status == STATUS_CRACKED) break;
4723 if (data.devices_status == STATUS_ABORTED) break;
4724 if (data.devices_status == STATUS_QUIT) break;
4725 if (data.devices_status == STATUS_BYPASS) break;
4726 }
4727
4728 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4729
4730 if (data.devices_status == STATUS_CRACKED) break;
4731 if (data.devices_status == STATUS_ABORTED) break;
4732 if (data.devices_status == STATUS_QUIT) break;
4733 if (data.devices_status == STATUS_BYPASS) break;
4734 }
4735
4736 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4737
4738 if (data.devices_status == STATUS_CRACKED) break;
4739 if (data.devices_status == STATUS_ABORTED) break;
4740 if (data.devices_status == STATUS_QUIT) break;
4741 if (data.devices_status == STATUS_BYPASS) break;
4742
4743 //
4744 // flush
4745 //
4746
4747 const uint pws_cnt = device_param->pws_cnt;
4748
4749 if (pws_cnt)
4750 {
4751 run_copy (device_param, pws_cnt);
4752
4753 run_cracker (device_param, pws_cnt);
4754
4755 device_param->pws_cnt = 0;
4756
4757 if (attack_kern == ATTACK_KERN_STRAIGHT)
4758 {
4759 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4760 }
4761 else if (attack_kern == ATTACK_KERN_COMBI)
4762 {
4763 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4764 }
4765 }
4766
4767 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4768
4769 if (data.devices_status == STATUS_CRACKED) break;
4770 if (data.devices_status == STATUS_ABORTED) break;
4771 if (data.devices_status == STATUS_QUIT) break;
4772 if (data.devices_status == STATUS_BYPASS) break;
4773
4774 if (words_fin == 0) break;
4775
4776 device_param->words_done = words_fin;
4777 }
4778
4779 if (attack_mode == ATTACK_MODE_COMBI)
4780 {
4781 fclose (device_param->combs_fp);
4782 }
4783
4784 free (wl_data->buf);
4785 free (wl_data);
4786
4787 fclose (fd);
4788 }
4789
4790 device_param->kernel_accel = 0;
4791 device_param->kernel_loops = 0;
4792
4793 return NULL;
4794 }
4795
4796 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4797 {
4798 if (!device_param)
4799 {
4800 log_error ("ERROR: %s : Invalid argument", __func__);
4801
4802 exit (-1);
4803 }
4804
4805 salt_t *salt_buf = &data.salts_buf[salt_pos];
4806
4807 device_param->kernel_params_buf32[24] = salt_pos;
4808 device_param->kernel_params_buf32[27] = 1;
4809 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4810 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4811 device_param->kernel_params_buf32[30] = 0;
4812 device_param->kernel_params_buf32[31] = 1;
4813
4814 char *dictfile_old = data.dictfile;
4815
4816 const char *weak_hash_check = "weak-hash-check";
4817
4818 data.dictfile = (char *) weak_hash_check;
4819
4820 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4821
4822 data.kernel_rules_buf[0].cmds[0] = 0;
4823
4824 /**
4825 * run the kernel
4826 */
4827
4828 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4829 {
4830 run_kernel (KERN_RUN_1, device_param, 1, false);
4831 }
4832 else
4833 {
4834 run_kernel (KERN_RUN_1, device_param, 1, false);
4835
4836 uint loop_step = 16;
4837
4838 const uint iter = salt_buf->salt_iter;
4839
4840 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4841 {
4842 uint loop_left = iter - loop_pos;
4843
4844 loop_left = MIN (loop_left, loop_step);
4845
4846 device_param->kernel_params_buf32[25] = loop_pos;
4847 device_param->kernel_params_buf32[26] = loop_left;
4848
4849 run_kernel (KERN_RUN_2, device_param, 1, false);
4850 }
4851
4852 run_kernel (KERN_RUN_3, device_param, 1, false);
4853 }
4854
4855 /**
4856 * result
4857 */
4858
4859 check_cracked (device_param, salt_pos);
4860
4861 /**
4862 * cleanup
4863 */
4864
4865 device_param->kernel_params_buf32[24] = 0;
4866 device_param->kernel_params_buf32[25] = 0;
4867 device_param->kernel_params_buf32[26] = 0;
4868 device_param->kernel_params_buf32[27] = 0;
4869 device_param->kernel_params_buf32[28] = 0;
4870 device_param->kernel_params_buf32[29] = 0;
4871 device_param->kernel_params_buf32[30] = 0;
4872 device_param->kernel_params_buf32[31] = 0;
4873
4874 data.dictfile = dictfile_old;
4875
4876 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4877 }
4878
4879 // hlfmt hashcat
4880
4881 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4882 {
4883 if (data.username == 0)
4884 {
4885 *hashbuf_pos = line_buf;
4886 *hashbuf_len = line_len;
4887 }
4888 else
4889 {
4890 char *pos = line_buf;
4891 int len = line_len;
4892
4893 for (int i = 0; i < line_len; i++, pos++, len--)
4894 {
4895 if (line_buf[i] == data.separator)
4896 {
4897 pos++;
4898
4899 len--;
4900
4901 break;
4902 }
4903 }
4904
4905 *hashbuf_pos = pos;
4906 *hashbuf_len = len;
4907 }
4908 }
4909
4910 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4911 {
4912 char *pos = NULL;
4913 int len = 0;
4914
4915 int sep_cnt = 0;
4916
4917 for (int i = 0; i < line_len; i++)
4918 {
4919 if (line_buf[i] == data.separator)
4920 {
4921 sep_cnt++;
4922
4923 continue;
4924 }
4925
4926 if (sep_cnt == 0)
4927 {
4928 if (pos == NULL) pos = line_buf + i;
4929
4930 len++;
4931 }
4932 }
4933
4934 *userbuf_pos = pos;
4935 *userbuf_len = len;
4936 }
4937
4938 // hlfmt pwdump
4939
4940 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
4941 {
4942 int sep_cnt = 0;
4943
4944 int sep2_len = 0;
4945 int sep3_len = 0;
4946
4947 for (int i = 0; i < line_len; i++)
4948 {
4949 if (line_buf[i] == ':')
4950 {
4951 sep_cnt++;
4952
4953 continue;
4954 }
4955
4956 if (sep_cnt == 2) sep2_len++;
4957 if (sep_cnt == 3) sep3_len++;
4958 }
4959
4960 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4961
4962 return 0;
4963 }
4964
4965 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4966 {
4967 char *pos = NULL;
4968 int len = 0;
4969
4970 int sep_cnt = 0;
4971
4972 for (int i = 0; i < line_len; i++)
4973 {
4974 if (line_buf[i] == ':')
4975 {
4976 sep_cnt++;
4977
4978 continue;
4979 }
4980
4981 if (data.hash_mode == 1000)
4982 {
4983 if (sep_cnt == 3)
4984 {
4985 if (pos == NULL) pos = line_buf + i;
4986
4987 len++;
4988 }
4989 }
4990 else if (data.hash_mode == 3000)
4991 {
4992 if (sep_cnt == 2)
4993 {
4994 if (pos == NULL) pos = line_buf + i;
4995
4996 len++;
4997 }
4998 }
4999 }
5000
5001 *hashbuf_pos = pos;
5002 *hashbuf_len = len;
5003 }
5004
5005 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5006 {
5007 char *pos = NULL;
5008 int len = 0;
5009
5010 int sep_cnt = 0;
5011
5012 for (int i = 0; i < line_len; i++)
5013 {
5014 if (line_buf[i] == ':')
5015 {
5016 sep_cnt++;
5017
5018 continue;
5019 }
5020
5021 if (sep_cnt == 0)
5022 {
5023 if (pos == NULL) pos = line_buf + i;
5024
5025 len++;
5026 }
5027 }
5028
5029 *userbuf_pos = pos;
5030 *userbuf_len = len;
5031 }
5032
5033 // hlfmt passwd
5034
5035 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5036 {
5037 int sep_cnt = 0;
5038
5039 char sep5_first = 0;
5040 char sep6_first = 0;
5041
5042 for (int i = 0; i < line_len; i++)
5043 {
5044 if (line_buf[i] == ':')
5045 {
5046 sep_cnt++;
5047
5048 continue;
5049 }
5050
5051 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5052 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5053 }
5054
5055 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5056
5057 return 0;
5058 }
5059
5060 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5061 {
5062 char *pos = NULL;
5063 int len = 0;
5064
5065 int sep_cnt = 0;
5066
5067 for (int i = 0; i < line_len; i++)
5068 {
5069 if (line_buf[i] == ':')
5070 {
5071 sep_cnt++;
5072
5073 continue;
5074 }
5075
5076 if (sep_cnt == 1)
5077 {
5078 if (pos == NULL) pos = line_buf + i;
5079
5080 len++;
5081 }
5082 }
5083
5084 *hashbuf_pos = pos;
5085 *hashbuf_len = len;
5086 }
5087
5088 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5089 {
5090 char *pos = NULL;
5091 int len = 0;
5092
5093 int sep_cnt = 0;
5094
5095 for (int i = 0; i < line_len; i++)
5096 {
5097 if (line_buf[i] == ':')
5098 {
5099 sep_cnt++;
5100
5101 continue;
5102 }
5103
5104 if (sep_cnt == 0)
5105 {
5106 if (pos == NULL) pos = line_buf + i;
5107
5108 len++;
5109 }
5110 }
5111
5112 *userbuf_pos = pos;
5113 *userbuf_len = len;
5114 }
5115
5116 // hlfmt shadow
5117
5118 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5119 {
5120 int sep_cnt = 0;
5121
5122 for (int i = 0; i < line_len; i++)
5123 {
5124 if (line_buf[i] == ':') sep_cnt++;
5125 }
5126
5127 if (sep_cnt == 8) return 1;
5128
5129 return 0;
5130 }
5131
5132 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5133 {
5134 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5135 }
5136
5137 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5138 {
5139 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5140 }
5141
5142 // hlfmt main
5143
5144 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5145 {
5146 switch (hashfile_format)
5147 {
5148 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5149 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5150 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5151 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5152 }
5153 }
5154
5155 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5156 {
5157 switch (hashfile_format)
5158 {
5159 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5160 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5161 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5162 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5163 }
5164 }
5165
5166 char *strhlfmt (const uint hashfile_format)
5167 {
5168 switch (hashfile_format)
5169 {
5170 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5171 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5172 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5173 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5174 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5175 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5176 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5177 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5178 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5179 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5180 }
5181
5182 return ((char *) "Unknown");
5183 }
5184
5185 static uint hlfmt_detect (FILE *fp, uint max_check)
5186 {
5187 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5188
5189 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5190 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5191
5192 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5193
5194 uint num_check = 0;
5195
5196 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5197
5198 while (!feof (fp))
5199 {
5200 int line_len = fgetl (fp, line_buf);
5201
5202 if (line_len == 0) continue;
5203
5204 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5205 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5206 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5207
5208 if (num_check == max_check) break;
5209
5210 num_check++;
5211 }
5212
5213 myfree (line_buf);
5214
5215 uint hashlist_format = HLFMT_HASHCAT;
5216
5217 for (int i = 1; i < HLFMTS_CNT; i++)
5218 {
5219 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5220
5221 hashlist_format = i;
5222 }
5223
5224 free (formats_cnt);
5225
5226 return hashlist_format;
5227 }
5228
5229 /**
5230 * some further helper function
5231 */
5232
5233 // wrapper around mymalloc for ADL
5234
5235 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5236 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5237 {
5238 return mymalloc (iSize);
5239 }
5240 #endif
5241
5242 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)
5243 {
5244 u64 collisions = 0;
5245
5246 const uint dgst_pos0 = data.dgst_pos0;
5247 const uint dgst_pos1 = data.dgst_pos1;
5248 const uint dgst_pos2 = data.dgst_pos2;
5249 const uint dgst_pos3 = data.dgst_pos3;
5250
5251 memset (bitmap_a, 0, bitmap_size);
5252 memset (bitmap_b, 0, bitmap_size);
5253 memset (bitmap_c, 0, bitmap_size);
5254 memset (bitmap_d, 0, bitmap_size);
5255
5256 for (uint i = 0; i < digests_cnt; i++)
5257 {
5258 uint *digest_ptr = (uint *) digests_buf_ptr;
5259
5260 digests_buf_ptr += dgst_size;
5261
5262 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5263 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5264 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5265 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5266
5267 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5268 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5269 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5270 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5271
5272 if (bitmap_a[idx0] & val0) collisions++;
5273 if (bitmap_b[idx1] & val1) collisions++;
5274 if (bitmap_c[idx2] & val2) collisions++;
5275 if (bitmap_d[idx3] & val3) collisions++;
5276
5277 bitmap_a[idx0] |= val0;
5278 bitmap_b[idx1] |= val1;
5279 bitmap_c[idx2] |= val2;
5280 bitmap_d[idx3] |= val3;
5281
5282 if (collisions >= collisions_max) return 0x7fffffff;
5283 }
5284
5285 return collisions;
5286 }
5287
5288 /**
5289 * main
5290 */
5291
5292 int main (int argc, char **argv)
5293 {
5294 /**
5295 * To help users a bit
5296 */
5297
5298 char *compute = getenv ("COMPUTE");
5299
5300 if (compute)
5301 {
5302 static char display[100];
5303
5304 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5305
5306 putenv (display);
5307 }
5308 else
5309 {
5310 if (getenv ("DISPLAY") == NULL)
5311 putenv ((char *) "DISPLAY=:0");
5312 }
5313
5314 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5315 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5316
5317 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5318 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5319
5320 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5321 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5322
5323 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5324 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5325
5326 /**
5327 * Real init
5328 */
5329
5330 memset (&data, 0, sizeof (hc_global_data_t));
5331
5332 time_t proc_start;
5333
5334 time (&proc_start);
5335
5336 data.proc_start = proc_start;
5337
5338 int myargc = argc;
5339 char **myargv = argv;
5340
5341 hc_thread_mutex_init (mux_dispatcher);
5342 hc_thread_mutex_init (mux_counter);
5343 hc_thread_mutex_init (mux_display);
5344 hc_thread_mutex_init (mux_adl);
5345
5346 /**
5347 * commandline parameters
5348 */
5349
5350 uint usage = USAGE;
5351 uint version = VERSION;
5352 uint quiet = QUIET;
5353 uint benchmark = BENCHMARK;
5354 uint benchmark_repeats = BENCHMARK_REPEATS;
5355 uint show = SHOW;
5356 uint left = LEFT;
5357 uint username = USERNAME;
5358 uint remove = REMOVE;
5359 uint remove_timer = REMOVE_TIMER;
5360 u64 skip = SKIP;
5361 u64 limit = LIMIT;
5362 uint keyspace = KEYSPACE;
5363 uint potfile_disable = POTFILE_DISABLE;
5364 char *potfile_path = NULL;
5365 uint debug_mode = DEBUG_MODE;
5366 char *debug_file = NULL;
5367 char *induction_dir = NULL;
5368 char *outfile_check_dir = NULL;
5369 uint force = FORCE;
5370 uint runtime = RUNTIME;
5371 uint hash_mode = HASH_MODE;
5372 uint attack_mode = ATTACK_MODE;
5373 uint markov_disable = MARKOV_DISABLE;
5374 uint markov_classic = MARKOV_CLASSIC;
5375 uint markov_threshold = MARKOV_THRESHOLD;
5376 char *markov_hcstat = NULL;
5377 char *outfile = NULL;
5378 uint outfile_format = OUTFILE_FORMAT;
5379 uint outfile_autohex = OUTFILE_AUTOHEX;
5380 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5381 uint restore = RESTORE;
5382 uint restore_timer = RESTORE_TIMER;
5383 uint restore_disable = RESTORE_DISABLE;
5384 uint status = STATUS;
5385 uint status_timer = STATUS_TIMER;
5386 uint status_automat = STATUS_AUTOMAT;
5387 uint loopback = LOOPBACK;
5388 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5389 char *session = NULL;
5390 uint hex_charset = HEX_CHARSET;
5391 uint hex_salt = HEX_SALT;
5392 uint hex_wordlist = HEX_WORDLIST;
5393 uint rp_gen = RP_GEN;
5394 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5395 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5396 uint rp_gen_seed = RP_GEN_SEED;
5397 char *rule_buf_l = (char *) RULE_BUF_L;
5398 char *rule_buf_r = (char *) RULE_BUF_R;
5399 uint increment = INCREMENT;
5400 uint increment_min = INCREMENT_MIN;
5401 uint increment_max = INCREMENT_MAX;
5402 char *cpu_affinity = NULL;
5403 OCL_PTR *ocl = NULL;
5404 char *opencl_devices = NULL;
5405 char *opencl_platforms = NULL;
5406 char *opencl_device_types = NULL;
5407 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5408 char *truecrypt_keyfiles = NULL;
5409 uint workload_profile = WORKLOAD_PROFILE;
5410 uint kernel_accel = KERNEL_ACCEL;
5411 uint kernel_loops = KERNEL_LOOPS;
5412 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5413 #ifdef HAVE_HWMON
5414 uint gpu_temp_abort = GPU_TEMP_ABORT;
5415 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5416 #ifdef HAVE_ADL
5417 uint powertune_enable = POWERTUNE_ENABLE;
5418 #endif
5419 #endif
5420 uint logfile_disable = LOGFILE_DISABLE;
5421 uint segment_size = SEGMENT_SIZE;
5422 uint scrypt_tmto = SCRYPT_TMTO;
5423 char separator = SEPARATOR;
5424 uint bitmap_min = BITMAP_MIN;
5425 uint bitmap_max = BITMAP_MAX;
5426 char *custom_charset_1 = NULL;
5427 char *custom_charset_2 = NULL;
5428 char *custom_charset_3 = NULL;
5429 char *custom_charset_4 = NULL;
5430
5431 #define IDX_HELP 'h'
5432 #define IDX_VERSION 'V'
5433 #define IDX_VERSION_LOWER 'v'
5434 #define IDX_QUIET 0xff02
5435 #define IDX_SHOW 0xff03
5436 #define IDX_LEFT 0xff04
5437 #define IDX_REMOVE 0xff05
5438 #define IDX_REMOVE_TIMER 0xff37
5439 #define IDX_SKIP 's'
5440 #define IDX_LIMIT 'l'
5441 #define IDX_KEYSPACE 0xff35
5442 #define IDX_POTFILE_DISABLE 0xff06
5443 #define IDX_POTFILE_PATH 0xffe0
5444 #define IDX_DEBUG_MODE 0xff43
5445 #define IDX_DEBUG_FILE 0xff44
5446 #define IDX_INDUCTION_DIR 0xff46
5447 #define IDX_OUTFILE_CHECK_DIR 0xff47
5448 #define IDX_USERNAME 0xff07
5449 #define IDX_FORCE 0xff08
5450 #define IDX_RUNTIME 0xff09
5451 #define IDX_BENCHMARK 'b'
5452 #define IDX_BENCHMARK_REPEATS 0xff78
5453 #define IDX_HASH_MODE 'm'
5454 #define IDX_ATTACK_MODE 'a'
5455 #define IDX_RP_FILE 'r'
5456 #define IDX_RP_GEN 'g'
5457 #define IDX_RP_GEN_FUNC_MIN 0xff10
5458 #define IDX_RP_GEN_FUNC_MAX 0xff11
5459 #define IDX_RP_GEN_SEED 0xff34
5460 #define IDX_RULE_BUF_L 'j'
5461 #define IDX_RULE_BUF_R 'k'
5462 #define IDX_INCREMENT 'i'
5463 #define IDX_INCREMENT_MIN 0xff12
5464 #define IDX_INCREMENT_MAX 0xff13
5465 #define IDX_OUTFILE 'o'
5466 #define IDX_OUTFILE_FORMAT 0xff14
5467 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5468 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5469 #define IDX_RESTORE 0xff15
5470 #define IDX_RESTORE_DISABLE 0xff27
5471 #define IDX_STATUS 0xff17
5472 #define IDX_STATUS_TIMER 0xff18
5473 #define IDX_STATUS_AUTOMAT 0xff50
5474 #define IDX_LOOPBACK 0xff38
5475 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5476 #define IDX_SESSION 0xff19
5477 #define IDX_HEX_CHARSET 0xff20
5478 #define IDX_HEX_SALT 0xff21
5479 #define IDX_HEX_WORDLIST 0xff40
5480 #define IDX_MARKOV_DISABLE 0xff22
5481 #define IDX_MARKOV_CLASSIC 0xff23
5482 #define IDX_MARKOV_THRESHOLD 't'
5483 #define IDX_MARKOV_HCSTAT 0xff24
5484 #define IDX_CPU_AFFINITY 0xff25
5485 #define IDX_OPENCL_DEVICES 'd'
5486 #define IDX_OPENCL_PLATFORMS 0xff72
5487 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5488 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5489 #define IDX_WORKLOAD_PROFILE 'w'
5490 #define IDX_KERNEL_ACCEL 'n'
5491 #define IDX_KERNEL_LOOPS 'u'
5492 #define IDX_GPU_TEMP_DISABLE 0xff29
5493 #define IDX_GPU_TEMP_ABORT 0xff30
5494 #define IDX_GPU_TEMP_RETAIN 0xff31
5495 #define IDX_POWERTUNE_ENABLE 0xff41
5496 #define IDX_LOGFILE_DISABLE 0xff51
5497 #define IDX_TRUECRYPT_KEYFILES 0xff52
5498 #define IDX_SCRYPT_TMTO 0xff61
5499 #define IDX_SEGMENT_SIZE 'c'
5500 #define IDX_SEPARATOR 'p'
5501 #define IDX_BITMAP_MIN 0xff70
5502 #define IDX_BITMAP_MAX 0xff71
5503 #define IDX_CUSTOM_CHARSET_1 '1'
5504 #define IDX_CUSTOM_CHARSET_2 '2'
5505 #define IDX_CUSTOM_CHARSET_3 '3'
5506 #define IDX_CUSTOM_CHARSET_4 '4'
5507
5508 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5509
5510 struct option long_options[] =
5511 {
5512 {"help", no_argument, 0, IDX_HELP},
5513 {"version", no_argument, 0, IDX_VERSION},
5514 {"quiet", no_argument, 0, IDX_QUIET},
5515 {"show", no_argument, 0, IDX_SHOW},
5516 {"left", no_argument, 0, IDX_LEFT},
5517 {"username", no_argument, 0, IDX_USERNAME},
5518 {"remove", no_argument, 0, IDX_REMOVE},
5519 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5520 {"skip", required_argument, 0, IDX_SKIP},
5521 {"limit", required_argument, 0, IDX_LIMIT},
5522 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5523 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5524 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5525 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5526 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5527 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5528 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5529 {"force", no_argument, 0, IDX_FORCE},
5530 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5531 {"benchmark-repeats", required_argument, 0, IDX_BENCHMARK_REPEATS},
5532 {"restore", no_argument, 0, IDX_RESTORE},
5533 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5534 {"status", no_argument, 0, IDX_STATUS},
5535 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5536 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5537 {"loopback", no_argument, 0, IDX_LOOPBACK},
5538 {"weak-hash-threshold",
5539 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5540 {"session", required_argument, 0, IDX_SESSION},
5541 {"runtime", required_argument, 0, IDX_RUNTIME},
5542 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5543 {"generate-rules-func-min",
5544 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5545 {"generate-rules-func-max",
5546 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5547 {"generate-rules-seed",
5548 required_argument, 0, IDX_RP_GEN_SEED},
5549 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5550 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5551 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5552 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5553 {"rules-file", required_argument, 0, IDX_RP_FILE},
5554 {"outfile", required_argument, 0, IDX_OUTFILE},
5555 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5556 {"outfile-autohex-disable",
5557 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5558 {"outfile-check-timer",
5559 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5560 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5561 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5562 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5563 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5564 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5565 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5566 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5567 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5568 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5569 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5570 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5571 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5572 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5573 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5574 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5575 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5576 #ifdef HAVE_HWMON
5577 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5578 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5579 #ifdef HAVE_ADL
5580 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5581 #endif
5582 #endif // HAVE_HWMON
5583 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5584 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5585 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5586 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5587 // deprecated
5588 {"seperator", required_argument, 0, IDX_SEPARATOR},
5589 {"separator", required_argument, 0, IDX_SEPARATOR},
5590 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5591 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5592 {"increment", no_argument, 0, IDX_INCREMENT},
5593 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5594 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5595 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5596 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5597 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5598 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5599
5600 {0, 0, 0, 0}
5601 };
5602
5603 uint rp_files_cnt = 0;
5604
5605 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5606
5607 int option_index = 0;
5608 int c = -1;
5609
5610 optind = 1;
5611 optopt = 0;
5612
5613 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5614 {
5615 switch (c)
5616 {
5617 case IDX_HELP: usage = 1; break;
5618 case IDX_VERSION:
5619 case IDX_VERSION_LOWER: version = 1; break;
5620 case IDX_RESTORE: restore = 1; break;
5621 case IDX_SESSION: session = optarg; break;
5622 case IDX_SHOW: show = 1; break;
5623 case IDX_LEFT: left = 1; break;
5624 case '?': return (-1);
5625 }
5626 }
5627
5628 if (optopt != 0)
5629 {
5630 log_error ("ERROR: Invalid argument specified");
5631
5632 return (-1);
5633 }
5634
5635 /**
5636 * exit functions
5637 */
5638
5639 if (version)
5640 {
5641 log_info ("%s (%s)", VERSION_TAG, VERSION_SUM);
5642
5643 return (0);
5644 }
5645
5646 if (usage)
5647 {
5648 usage_big_print (PROGNAME);
5649
5650 return (0);
5651 }
5652
5653 /**
5654 * session needs to be set, always!
5655 */
5656
5657 if (session == NULL) session = (char *) PROGNAME;
5658
5659 /**
5660 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5661 */
5662
5663 char *exec_path = get_exec_path ();
5664
5665 #ifdef LINUX
5666
5667 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5668 char *resolved_exec_path = realpath (exec_path, NULL);
5669
5670 char *install_dir = get_install_dir (resolved_exec_path);
5671 char *profile_dir = NULL;
5672 char *session_dir = NULL;
5673 char *shared_dir = NULL;
5674
5675 if (strcmp (install_dir, resolved_install_folder) == 0)
5676 {
5677 struct passwd *pw = getpwuid (getuid ());
5678
5679 const char *homedir = pw->pw_dir;
5680
5681 profile_dir = get_profile_dir (homedir);
5682 session_dir = get_session_dir (profile_dir);
5683 shared_dir = strdup (SHARED_FOLDER);
5684
5685 mkdir (profile_dir, 0700);
5686 mkdir (session_dir, 0700);
5687 }
5688 else
5689 {
5690 profile_dir = install_dir;
5691 session_dir = install_dir;
5692 shared_dir = install_dir;
5693 }
5694
5695 myfree (resolved_install_folder);
5696 myfree (resolved_exec_path);
5697
5698 #else
5699
5700 char *install_dir = get_install_dir (exec_path);
5701 char *profile_dir = install_dir;
5702 char *session_dir = install_dir;
5703 char *shared_dir = install_dir;
5704
5705 #endif
5706
5707 data.install_dir = install_dir;
5708 data.profile_dir = profile_dir;
5709 data.session_dir = session_dir;
5710 data.shared_dir = shared_dir;
5711
5712 myfree (exec_path);
5713
5714 /**
5715 * kernel cache, we need to make sure folder exist
5716 */
5717
5718 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5719
5720 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5721
5722 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5723
5724 mkdir (kernels_folder, 0700);
5725
5726 myfree (kernels_folder);
5727
5728 /**
5729 * session
5730 */
5731
5732 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5733
5734 data.session = session;
5735
5736 char *eff_restore_file = (char *) mymalloc (session_size);
5737 char *new_restore_file = (char *) mymalloc (session_size);
5738
5739 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5740 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5741
5742 data.eff_restore_file = eff_restore_file;
5743 data.new_restore_file = new_restore_file;
5744
5745 if (((show == 1) || (left == 1)) && (restore == 1))
5746 {
5747 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5748 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5749
5750 return (-1);
5751 }
5752
5753 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5754 if ((show == 1) || (left == 1))
5755 {
5756 restore_disable = 1;
5757
5758 restore = 0;
5759 }
5760
5761 data.restore_disable = restore_disable;
5762
5763 restore_data_t *rd = init_restore (argc, argv);
5764
5765 data.rd = rd;
5766
5767 /**
5768 * restore file
5769 */
5770
5771 if (restore == 1)
5772 {
5773 read_restore (eff_restore_file, rd);
5774
5775 if (rd->version_bin < RESTORE_MIN)
5776 {
5777 log_error ("ERROR: Incompatible restore-file version");
5778
5779 return (-1);
5780 }
5781
5782 myargc = rd->argc;
5783 myargv = rd->argv;
5784
5785 #ifdef _POSIX
5786 rd->pid = getpid ();
5787 #elif _WIN
5788 rd->pid = GetCurrentProcessId ();
5789 #endif
5790 }
5791
5792 uint hash_mode_chgd = 0;
5793 uint runtime_chgd = 0;
5794 uint kernel_loops_chgd = 0;
5795 uint kernel_accel_chgd = 0;
5796 uint attack_mode_chgd = 0;
5797 uint outfile_format_chgd = 0;
5798 uint rp_gen_seed_chgd = 0;
5799 uint remove_timer_chgd = 0;
5800 uint increment_min_chgd = 0;
5801 uint increment_max_chgd = 0;
5802 uint workload_profile_chgd = 0;
5803 uint opencl_vector_width_chgd = 0;
5804
5805 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5806 uint gpu_temp_retain_chgd = 0;
5807 uint gpu_temp_abort_chgd = 0;
5808 #endif
5809
5810 optind = 1;
5811 optopt = 0;
5812 option_index = 0;
5813
5814 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5815 {
5816 switch (c)
5817 {
5818 //case IDX_HELP: usage = 1; break;
5819 //case IDX_VERSION: version = 1; break;
5820 //case IDX_RESTORE: restore = 1; break;
5821 case IDX_QUIET: quiet = 1; break;
5822 //case IDX_SHOW: show = 1; break;
5823 case IDX_SHOW: break;
5824 //case IDX_LEFT: left = 1; break;
5825 case IDX_LEFT: break;
5826 case IDX_USERNAME: username = 1; break;
5827 case IDX_REMOVE: remove = 1; break;
5828 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5829 remove_timer_chgd = 1; break;
5830 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5831 case IDX_POTFILE_PATH: potfile_path = optarg; break;
5832 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5833 case IDX_DEBUG_FILE: debug_file = optarg; break;
5834 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5835 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5836 case IDX_FORCE: force = 1; break;
5837 case IDX_SKIP: skip = atoll (optarg); break;
5838 case IDX_LIMIT: limit = atoll (optarg); break;
5839 case IDX_KEYSPACE: keyspace = 1; break;
5840 case IDX_BENCHMARK: benchmark = 1; break;
5841 case IDX_BENCHMARK_REPEATS: benchmark_repeats = atoi (optarg); break;
5842 case IDX_RESTORE: break;
5843 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5844 case IDX_STATUS: status = 1; break;
5845 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5846 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5847 case IDX_LOOPBACK: loopback = 1; break;
5848 case IDX_WEAK_HASH_THRESHOLD:
5849 weak_hash_threshold = atoi (optarg); break;
5850 //case IDX_SESSION: session = optarg; break;
5851 case IDX_SESSION: break;
5852 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5853 hash_mode_chgd = 1; break;
5854 case IDX_RUNTIME: runtime = atoi (optarg);
5855 runtime_chgd = 1; break;
5856 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5857 attack_mode_chgd = 1; break;
5858 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5859 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5860 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5861 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5862 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5863 rp_gen_seed_chgd = 1; break;
5864 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5865 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5866 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5867 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5868 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5869 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5870 case IDX_OUTFILE: outfile = optarg; break;
5871 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5872 outfile_format_chgd = 1; break;
5873 case IDX_OUTFILE_AUTOHEX_DISABLE:
5874 outfile_autohex = 0; break;
5875 case IDX_OUTFILE_CHECK_TIMER:
5876 outfile_check_timer = atoi (optarg); break;
5877 case IDX_HEX_CHARSET: hex_charset = 1; break;
5878 case IDX_HEX_SALT: hex_salt = 1; break;
5879 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5880 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5881 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5882 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5883 case IDX_OPENCL_DEVICE_TYPES:
5884 opencl_device_types = optarg; break;
5885 case IDX_OPENCL_VECTOR_WIDTH:
5886 opencl_vector_width = atoi (optarg);
5887 opencl_vector_width_chgd = 1; break;
5888 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
5889 workload_profile_chgd = 1; break;
5890 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5891 kernel_accel_chgd = 1; break;
5892 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5893 kernel_loops_chgd = 1; break;
5894 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5895 #ifdef HAVE_HWMON
5896 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5897 #ifdef HAVE_ADL
5898 gpu_temp_abort_chgd = 1;
5899 #endif
5900 break;
5901 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5902 #ifdef HAVE_ADL
5903 gpu_temp_retain_chgd = 1;
5904 #endif
5905 break;
5906 #ifdef HAVE_ADL
5907 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5908 #endif
5909 #endif // HAVE_HWMON
5910 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5911 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5912 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5913 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5914 case IDX_SEPARATOR: separator = optarg[0]; break;
5915 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5916 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5917 case IDX_INCREMENT: increment = 1; break;
5918 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5919 increment_min_chgd = 1; break;
5920 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5921 increment_max_chgd = 1; break;
5922 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5923 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5924 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5925 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5926
5927 default:
5928 log_error ("ERROR: Invalid argument specified");
5929 return (-1);
5930 }
5931 }
5932
5933 if (optopt != 0)
5934 {
5935 log_error ("ERROR: Invalid argument specified");
5936
5937 return (-1);
5938 }
5939
5940 /**
5941 * Inform user things getting started,
5942 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5943 * - we do not need to check algorithm_pos
5944 */
5945
5946 if (quiet == 0)
5947 {
5948 if (benchmark == 1)
5949 {
5950 log_info ("%s %s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5951
5952 log_info ("");
5953 }
5954 else if (restore == 1)
5955 {
5956 log_info ("%s %s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5957
5958 log_info ("");
5959 }
5960 else
5961 {
5962 log_info ("%s %s (%s) starting...", PROGNAME, VERSION_TAG, VERSION_SUM);
5963
5964 log_info ("");
5965 }
5966 }
5967
5968 /**
5969 * sanity check
5970 */
5971
5972 if (attack_mode > 7)
5973 {
5974 log_error ("ERROR: Invalid attack-mode specified");
5975
5976 return (-1);
5977 }
5978
5979 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5980 {
5981 log_error ("ERROR: Invalid runtime specified");
5982
5983 return (-1);
5984 }
5985
5986 if (hash_mode_chgd && hash_mode > 13500) // just added to remove compiler warnings for hash_mode_chgd
5987 {
5988 log_error ("ERROR: Invalid hash-type specified");
5989
5990 return (-1);
5991 }
5992
5993 // renamed hash modes
5994
5995 if (hash_mode_chgd)
5996 {
5997 int n = -1;
5998
5999 switch (hash_mode)
6000 {
6001 case 123: n = 124;
6002 break;
6003 }
6004
6005 if (n >= 0)
6006 {
6007 log_error ("Old -m specified, use -m %d instead", n);
6008
6009 return (-1);
6010 }
6011 }
6012
6013 if (username == 1)
6014 {
6015 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
6016 {
6017 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6018
6019 return (-1);
6020 }
6021 }
6022
6023 if (outfile_format > 16)
6024 {
6025 log_error ("ERROR: Invalid outfile-format specified");
6026
6027 return (-1);
6028 }
6029
6030 if (left == 1)
6031 {
6032 if (outfile_format_chgd == 1)
6033 {
6034 if (outfile_format > 1)
6035 {
6036 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6037
6038 return (-1);
6039 }
6040 }
6041 else
6042 {
6043 outfile_format = OUTFILE_FMT_HASH;
6044 }
6045 }
6046
6047 if (show == 1)
6048 {
6049 if (outfile_format_chgd == 1)
6050 {
6051 if ((outfile_format > 7) && (outfile_format < 16))
6052 {
6053 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6054
6055 return (-1);
6056 }
6057 }
6058 }
6059
6060 if (increment_min < INCREMENT_MIN)
6061 {
6062 log_error ("ERROR: Invalid increment-min specified");
6063
6064 return (-1);
6065 }
6066
6067 if (increment_max > INCREMENT_MAX)
6068 {
6069 log_error ("ERROR: Invalid increment-max specified");
6070
6071 return (-1);
6072 }
6073
6074 if (increment_min > increment_max)
6075 {
6076 log_error ("ERROR: Invalid increment-min specified");
6077
6078 return (-1);
6079 }
6080
6081 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6082 {
6083 log_error ("ERROR: increment is not allowed in attack-mode 0");
6084
6085 return (-1);
6086 }
6087
6088 if ((increment == 0) && (increment_min_chgd == 1))
6089 {
6090 log_error ("ERROR: increment-min is only supported together with increment switch");
6091
6092 return (-1);
6093 }
6094
6095 if ((increment == 0) && (increment_max_chgd == 1))
6096 {
6097 log_error ("ERROR: increment-max is only supported together with increment switch");
6098
6099 return (-1);
6100 }
6101
6102 if (rp_files_cnt && rp_gen)
6103 {
6104 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6105
6106 return (-1);
6107 }
6108
6109 if (rp_files_cnt || rp_gen)
6110 {
6111 if (attack_mode != ATTACK_MODE_STRAIGHT)
6112 {
6113 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6114
6115 return (-1);
6116 }
6117 }
6118
6119 if (rp_gen_func_min > rp_gen_func_max)
6120 {
6121 log_error ("ERROR: Invalid rp-gen-func-min specified");
6122
6123 return (-1);
6124 }
6125
6126 if (kernel_accel_chgd == 1)
6127 {
6128 if (kernel_accel < 1)
6129 {
6130 log_error ("ERROR: Invalid kernel-accel specified");
6131
6132 return (-1);
6133 }
6134
6135 if (kernel_accel > 1024)
6136 {
6137 log_error ("ERROR: Invalid kernel-accel specified");
6138
6139 return (-1);
6140 }
6141 }
6142
6143 if (kernel_loops_chgd == 1)
6144 {
6145 if (kernel_loops < 1)
6146 {
6147 log_error ("ERROR: Invalid kernel-loops specified");
6148
6149 return (-1);
6150 }
6151
6152 if (kernel_loops > 1024)
6153 {
6154 log_error ("ERROR: Invalid kernel-loops specified");
6155
6156 return (-1);
6157 }
6158 }
6159
6160 if ((workload_profile < 1) || (workload_profile > 3))
6161 {
6162 log_error ("ERROR: workload-profile %i not available", workload_profile);
6163
6164 return (-1);
6165 }
6166
6167 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6168 {
6169 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6170
6171 return (-1);
6172 }
6173
6174 if (show == 1 || left == 1)
6175 {
6176 attack_mode = ATTACK_MODE_NONE;
6177
6178 if (remove == 1)
6179 {
6180 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6181
6182 return (-1);
6183 }
6184
6185 if (potfile_disable == 1)
6186 {
6187 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6188
6189 return (-1);
6190 }
6191 }
6192
6193 uint attack_kern = ATTACK_KERN_NONE;
6194
6195 switch (attack_mode)
6196 {
6197 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6198 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6199 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6200 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6201 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6202 }
6203
6204 if (benchmark == 0)
6205 {
6206 if (keyspace == 1)
6207 {
6208 int num_additional_params = 1;
6209
6210 if (attack_kern == ATTACK_KERN_COMBI)
6211 {
6212 num_additional_params = 2;
6213 }
6214
6215 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6216
6217 if (keyspace_wordlist_specified == 0) optind--;
6218 }
6219
6220 if (attack_kern == ATTACK_KERN_NONE)
6221 {
6222 if ((optind + 1) != myargc)
6223 {
6224 usage_mini_print (myargv[0]);
6225
6226 return (-1);
6227 }
6228 }
6229 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6230 {
6231 if ((optind + 1) > myargc)
6232 {
6233 usage_mini_print (myargv[0]);
6234
6235 return (-1);
6236 }
6237 }
6238 else if (attack_kern == ATTACK_KERN_COMBI)
6239 {
6240 if ((optind + 3) != myargc)
6241 {
6242 usage_mini_print (myargv[0]);
6243
6244 return (-1);
6245 }
6246 }
6247 else if (attack_kern == ATTACK_KERN_BF)
6248 {
6249 if ((optind + 1) > myargc)
6250 {
6251 usage_mini_print (myargv[0]);
6252
6253 return (-1);
6254 }
6255 }
6256 else
6257 {
6258 usage_mini_print (myargv[0]);
6259
6260 return (-1);
6261 }
6262 }
6263 else
6264 {
6265 if (myargv[optind] != 0)
6266 {
6267 log_error ("ERROR: Invalid argument for benchmark mode specified");
6268
6269 return (-1);
6270 }
6271
6272 if (attack_mode_chgd == 1)
6273 {
6274 if (attack_mode != ATTACK_MODE_BF)
6275 {
6276 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6277
6278 return (-1);
6279 }
6280 }
6281 }
6282
6283 if (skip != 0 && limit != 0)
6284 {
6285 limit += skip;
6286 }
6287
6288 if (keyspace == 1)
6289 {
6290 if (show == 1)
6291 {
6292 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6293
6294 return (-1);
6295 }
6296 else if (left == 1)
6297 {
6298 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6299
6300 return (-1);
6301 }
6302
6303 potfile_disable = 1;
6304
6305 restore_disable = 1;
6306
6307 restore = 0;
6308
6309 weak_hash_threshold = 0;
6310
6311 quiet = 1;
6312 }
6313
6314 if (remove_timer_chgd == 1)
6315 {
6316 if (remove == 0)
6317 {
6318 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6319
6320 return (-1);
6321 }
6322
6323 if (remove_timer < 1)
6324 {
6325 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6326
6327 return (-1);
6328 }
6329 }
6330
6331 if (loopback == 1)
6332 {
6333 if (attack_mode == ATTACK_MODE_STRAIGHT)
6334 {
6335 if ((rp_files_cnt == 0) && (rp_gen == 0))
6336 {
6337 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6338
6339 return (-1);
6340 }
6341 }
6342 else
6343 {
6344 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6345
6346 return (-1);
6347 }
6348 }
6349
6350 if (debug_mode > 0)
6351 {
6352 if (attack_mode != ATTACK_MODE_STRAIGHT)
6353 {
6354 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6355
6356 return (-1);
6357 }
6358
6359 if ((rp_files_cnt == 0) && (rp_gen == 0))
6360 {
6361 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6362
6363 return (-1);
6364 }
6365 }
6366
6367 if (debug_mode > 4)
6368 {
6369 log_error ("ERROR: Invalid debug-mode specified");
6370
6371 return (-1);
6372 }
6373
6374 if (debug_file != NULL)
6375 {
6376 if (debug_mode < 1)
6377 {
6378 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6379
6380 return (-1);
6381 }
6382 }
6383
6384 if (induction_dir != NULL)
6385 {
6386 if (attack_mode == ATTACK_MODE_BF)
6387 {
6388 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6389
6390 return (-1);
6391 }
6392 }
6393
6394 if (attack_mode != ATTACK_MODE_STRAIGHT)
6395 {
6396 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6397 {
6398 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6399
6400 return (-1);
6401 }
6402
6403 weak_hash_threshold = 0;
6404 }
6405
6406 /**
6407 * induction directory
6408 */
6409
6410 char *induction_directory = NULL;
6411
6412 if (attack_mode != ATTACK_MODE_BF)
6413 {
6414 if (induction_dir == NULL)
6415 {
6416 induction_directory = (char *) mymalloc (session_size);
6417
6418 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6419
6420 // create induction folder if it does not already exist
6421
6422 if (keyspace == 0)
6423 {
6424 if (rmdir (induction_directory) == -1)
6425 {
6426 if (errno == ENOENT)
6427 {
6428 // good, we can ignore
6429 }
6430 else if (errno == ENOTEMPTY)
6431 {
6432 char *induction_directory_mv = (char *) mymalloc (session_size);
6433
6434 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6435
6436 if (rename (induction_directory, induction_directory_mv) != 0)
6437 {
6438 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6439
6440 return (-1);
6441 }
6442 }
6443 else
6444 {
6445 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6446
6447 return (-1);
6448 }
6449 }
6450
6451 if (mkdir (induction_directory, 0700) == -1)
6452 {
6453 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6454
6455 return (-1);
6456 }
6457 }
6458 }
6459 else
6460 {
6461 induction_directory = induction_dir;
6462 }
6463 }
6464
6465 data.induction_directory = induction_directory;
6466
6467 /**
6468 * loopback
6469 */
6470
6471 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6472
6473 char *loopback_file = (char *) mymalloc (loopback_size);
6474
6475 /**
6476 * tuning db
6477 */
6478
6479 char tuning_db_file[256] = { 0 };
6480
6481 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6482
6483 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6484
6485 /**
6486 * outfile-check directory
6487 */
6488
6489 char *outfile_check_directory = NULL;
6490
6491 if (outfile_check_dir == NULL)
6492 {
6493 outfile_check_directory = (char *) mymalloc (session_size);
6494
6495 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6496 }
6497 else
6498 {
6499 outfile_check_directory = outfile_check_dir;
6500 }
6501
6502 data.outfile_check_directory = outfile_check_directory;
6503
6504 if (keyspace == 0)
6505 {
6506 struct stat outfile_check_stat;
6507
6508 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6509 {
6510 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6511
6512 if (is_dir == 0)
6513 {
6514 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6515
6516 return (-1);
6517 }
6518 }
6519 else if (outfile_check_dir == NULL)
6520 {
6521 if (mkdir (outfile_check_directory, 0700) == -1)
6522 {
6523 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6524
6525 return (-1);
6526 }
6527 }
6528 }
6529
6530 /**
6531 * special other stuff
6532 */
6533
6534 if (hash_mode == 9710)
6535 {
6536 outfile_format = 5;
6537 outfile_format_chgd = 1;
6538 }
6539
6540 if (hash_mode == 9810)
6541 {
6542 outfile_format = 5;
6543 outfile_format_chgd = 1;
6544 }
6545
6546 if (hash_mode == 10410)
6547 {
6548 outfile_format = 5;
6549 outfile_format_chgd = 1;
6550 }
6551
6552 /**
6553 * store stuff
6554 */
6555
6556 data.hash_mode = hash_mode;
6557 data.restore = restore;
6558 data.restore_timer = restore_timer;
6559 data.restore_disable = restore_disable;
6560 data.status = status;
6561 data.status_timer = status_timer;
6562 data.status_automat = status_automat;
6563 data.loopback = loopback;
6564 data.runtime = runtime;
6565 data.remove = remove;
6566 data.remove_timer = remove_timer;
6567 data.debug_mode = debug_mode;
6568 data.debug_file = debug_file;
6569 data.username = username;
6570 data.quiet = quiet;
6571 data.outfile = outfile;
6572 data.outfile_format = outfile_format;
6573 data.outfile_autohex = outfile_autohex;
6574 data.hex_charset = hex_charset;
6575 data.hex_salt = hex_salt;
6576 data.hex_wordlist = hex_wordlist;
6577 data.separator = separator;
6578 data.rp_files = rp_files;
6579 data.rp_files_cnt = rp_files_cnt;
6580 data.rp_gen = rp_gen;
6581 data.rp_gen_seed = rp_gen_seed;
6582 data.force = force;
6583 data.benchmark = benchmark;
6584 data.benchmark_repeats = benchmark_repeats;
6585 data.skip = skip;
6586 data.limit = limit;
6587 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6588 data.powertune_enable = powertune_enable;
6589 #endif
6590 data.logfile_disable = logfile_disable;
6591 data.truecrypt_keyfiles = truecrypt_keyfiles;
6592 data.scrypt_tmto = scrypt_tmto;
6593 data.workload_profile = workload_profile;
6594
6595 /**
6596 * cpu affinity
6597 */
6598
6599 if (cpu_affinity)
6600 {
6601 set_cpu_affinity (cpu_affinity);
6602 }
6603
6604 if (rp_gen_seed_chgd == 0)
6605 {
6606 srand (proc_start);
6607 }
6608 else
6609 {
6610 srand (rp_gen_seed);
6611 }
6612
6613 /**
6614 * logfile init
6615 */
6616
6617 if (logfile_disable == 0)
6618 {
6619 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6620
6621 char *logfile = (char *) mymalloc (logfile_size);
6622
6623 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6624
6625 data.logfile = logfile;
6626
6627 char *topid = logfile_generate_topid ();
6628
6629 data.topid = topid;
6630 }
6631
6632 // logfile_append() checks for logfile_disable internally to make it easier from here
6633
6634 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6635 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6636 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6637 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6638 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6639 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6640 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6641 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6642 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6643 #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));
6644
6645 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6646 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6647 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6648 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6649 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6650 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6651 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6652 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6653
6654 logfile_top_msg ("START");
6655
6656 logfile_top_uint (attack_mode);
6657 logfile_top_uint (attack_kern);
6658 logfile_top_uint (benchmark);
6659 logfile_top_uint (benchmark_repeats);
6660 logfile_top_uint (bitmap_min);
6661 logfile_top_uint (bitmap_max);
6662 logfile_top_uint (debug_mode);
6663 logfile_top_uint (force);
6664 logfile_top_uint (kernel_accel);
6665 logfile_top_uint (kernel_loops);
6666 logfile_top_uint (gpu_temp_disable);
6667 #ifdef HAVE_HWMON
6668 logfile_top_uint (gpu_temp_abort);
6669 logfile_top_uint (gpu_temp_retain);
6670 #endif
6671 logfile_top_uint (hash_mode);
6672 logfile_top_uint (hex_charset);
6673 logfile_top_uint (hex_salt);
6674 logfile_top_uint (hex_wordlist);
6675 logfile_top_uint (increment);
6676 logfile_top_uint (increment_max);
6677 logfile_top_uint (increment_min);
6678 logfile_top_uint (keyspace);
6679 logfile_top_uint (left);
6680 logfile_top_uint (logfile_disable);
6681 logfile_top_uint (loopback);
6682 logfile_top_uint (markov_classic);
6683 logfile_top_uint (markov_disable);
6684 logfile_top_uint (markov_threshold);
6685 logfile_top_uint (outfile_autohex);
6686 logfile_top_uint (outfile_check_timer);
6687 logfile_top_uint (outfile_format);
6688 logfile_top_uint (potfile_disable);
6689 logfile_top_string (potfile_path);
6690 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6691 logfile_top_uint (powertune_enable);
6692 #endif
6693 logfile_top_uint (scrypt_tmto);
6694 logfile_top_uint (quiet);
6695 logfile_top_uint (remove);
6696 logfile_top_uint (remove_timer);
6697 logfile_top_uint (restore);
6698 logfile_top_uint (restore_disable);
6699 logfile_top_uint (restore_timer);
6700 logfile_top_uint (rp_gen);
6701 logfile_top_uint (rp_gen_func_max);
6702 logfile_top_uint (rp_gen_func_min);
6703 logfile_top_uint (rp_gen_seed);
6704 logfile_top_uint (runtime);
6705 logfile_top_uint (segment_size);
6706 logfile_top_uint (show);
6707 logfile_top_uint (status);
6708 logfile_top_uint (status_automat);
6709 logfile_top_uint (status_timer);
6710 logfile_top_uint (usage);
6711 logfile_top_uint (username);
6712 logfile_top_uint (version);
6713 logfile_top_uint (weak_hash_threshold);
6714 logfile_top_uint (workload_profile);
6715 logfile_top_uint64 (limit);
6716 logfile_top_uint64 (skip);
6717 logfile_top_char (separator);
6718 logfile_top_string (cpu_affinity);
6719 logfile_top_string (custom_charset_1);
6720 logfile_top_string (custom_charset_2);
6721 logfile_top_string (custom_charset_3);
6722 logfile_top_string (custom_charset_4);
6723 logfile_top_string (debug_file);
6724 logfile_top_string (opencl_devices);
6725 logfile_top_string (opencl_platforms);
6726 logfile_top_string (opencl_device_types);
6727 logfile_top_uint (opencl_vector_width);
6728 logfile_top_string (induction_dir);
6729 logfile_top_string (markov_hcstat);
6730 logfile_top_string (outfile);
6731 logfile_top_string (outfile_check_dir);
6732 logfile_top_string (rule_buf_l);
6733 logfile_top_string (rule_buf_r);
6734 logfile_top_string (session);
6735 logfile_top_string (truecrypt_keyfiles);
6736
6737 /**
6738 * Init OpenCL library loader
6739 */
6740
6741 if (keyspace == 0)
6742 {
6743 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6744
6745 ocl_init (ocl);
6746
6747 data.ocl = ocl;
6748 }
6749
6750 /**
6751 * OpenCL platform selection
6752 */
6753
6754 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6755
6756 /**
6757 * OpenCL device selection
6758 */
6759
6760 u32 devices_filter = setup_devices_filter (opencl_devices);
6761
6762 /**
6763 * OpenCL device type selection
6764 */
6765
6766 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6767
6768 /**
6769 * benchmark
6770 */
6771
6772 if (benchmark == 1)
6773 {
6774 /**
6775 * disable useless stuff for benchmark
6776 */
6777
6778 status_timer = 0;
6779 restore_timer = 0;
6780 restore_disable = 1;
6781 potfile_disable = 1;
6782 weak_hash_threshold = 0;
6783 gpu_temp_disable = 1;
6784
6785 data.status_timer = status_timer;
6786 data.restore_timer = restore_timer;
6787 data.restore_disable = restore_disable;
6788
6789 /**
6790 * force attack mode to be bruteforce
6791 */
6792
6793 attack_mode = ATTACK_MODE_BF;
6794 attack_kern = ATTACK_KERN_BF;
6795
6796 if (workload_profile_chgd == 0)
6797 {
6798 workload_profile = 3;
6799
6800 data.workload_profile = workload_profile;
6801 }
6802 }
6803
6804 /**
6805 * config
6806 */
6807
6808 uint hash_type = 0;
6809 uint salt_type = 0;
6810 uint attack_exec = 0;
6811 uint opts_type = 0;
6812 uint kern_type = 0;
6813 uint dgst_size = 0;
6814 uint esalt_size = 0;
6815 uint opti_type = 0;
6816 uint dgst_pos0 = -1;
6817 uint dgst_pos1 = -1;
6818 uint dgst_pos2 = -1;
6819 uint dgst_pos3 = -1;
6820
6821 int (*parse_func) (char *, uint, hash_t *);
6822 int (*sort_by_digest) (const void *, const void *);
6823
6824 uint algorithm_pos = 0;
6825 uint algorithm_max = 1;
6826
6827 uint *algorithms = default_benchmark_algorithms;
6828
6829 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6830
6831 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6832 {
6833 /*
6834 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6835 * the following algos are skipped entirely
6836 */
6837
6838 if (algorithm_pos > 0)
6839 {
6840 local_free (rd);
6841
6842 rd = init_restore (argc, argv);
6843
6844 data.rd = rd;
6845 }
6846
6847 /**
6848 * update hash_mode in case of multihash benchmark
6849 */
6850
6851 if (benchmark == 1)
6852 {
6853 if (hash_mode_chgd == 0)
6854 {
6855 hash_mode = algorithms[algorithm_pos];
6856
6857 data.hash_mode = hash_mode;
6858 }
6859
6860 quiet = 1;
6861
6862 data.quiet = quiet;
6863 }
6864
6865 switch (hash_mode)
6866 {
6867 case 0: hash_type = HASH_TYPE_MD5;
6868 salt_type = SALT_TYPE_NONE;
6869 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6870 opts_type = OPTS_TYPE_PT_GENERATE_LE
6871 | OPTS_TYPE_PT_ADD80
6872 | OPTS_TYPE_PT_ADDBITS14;
6873 kern_type = KERN_TYPE_MD5;
6874 dgst_size = DGST_SIZE_4_4;
6875 parse_func = md5_parse_hash;
6876 sort_by_digest = sort_by_digest_4_4;
6877 opti_type = OPTI_TYPE_ZERO_BYTE
6878 | OPTI_TYPE_PRECOMPUTE_INIT
6879 | OPTI_TYPE_PRECOMPUTE_MERKLE
6880 | OPTI_TYPE_MEET_IN_MIDDLE
6881 | OPTI_TYPE_EARLY_SKIP
6882 | OPTI_TYPE_NOT_ITERATED
6883 | OPTI_TYPE_NOT_SALTED
6884 | OPTI_TYPE_RAW_HASH;
6885 dgst_pos0 = 0;
6886 dgst_pos1 = 3;
6887 dgst_pos2 = 2;
6888 dgst_pos3 = 1;
6889 break;
6890
6891 case 10: hash_type = HASH_TYPE_MD5;
6892 salt_type = SALT_TYPE_INTERN;
6893 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6894 opts_type = OPTS_TYPE_PT_GENERATE_LE
6895 | OPTS_TYPE_ST_ADD80
6896 | OPTS_TYPE_ST_ADDBITS14;
6897 kern_type = KERN_TYPE_MD5_PWSLT;
6898 dgst_size = DGST_SIZE_4_4;
6899 parse_func = md5s_parse_hash;
6900 sort_by_digest = sort_by_digest_4_4;
6901 opti_type = OPTI_TYPE_ZERO_BYTE
6902 | OPTI_TYPE_PRECOMPUTE_INIT
6903 | OPTI_TYPE_PRECOMPUTE_MERKLE
6904 | OPTI_TYPE_MEET_IN_MIDDLE
6905 | OPTI_TYPE_EARLY_SKIP
6906 | OPTI_TYPE_NOT_ITERATED
6907 | OPTI_TYPE_APPENDED_SALT
6908 | OPTI_TYPE_RAW_HASH;
6909 dgst_pos0 = 0;
6910 dgst_pos1 = 3;
6911 dgst_pos2 = 2;
6912 dgst_pos3 = 1;
6913 break;
6914
6915 case 11: hash_type = HASH_TYPE_MD5;
6916 salt_type = SALT_TYPE_INTERN;
6917 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6918 opts_type = OPTS_TYPE_PT_GENERATE_LE
6919 | OPTS_TYPE_ST_ADD80
6920 | OPTS_TYPE_ST_ADDBITS14;
6921 kern_type = KERN_TYPE_MD5_PWSLT;
6922 dgst_size = DGST_SIZE_4_4;
6923 parse_func = joomla_parse_hash;
6924 sort_by_digest = sort_by_digest_4_4;
6925 opti_type = OPTI_TYPE_ZERO_BYTE
6926 | OPTI_TYPE_PRECOMPUTE_INIT
6927 | OPTI_TYPE_PRECOMPUTE_MERKLE
6928 | OPTI_TYPE_MEET_IN_MIDDLE
6929 | OPTI_TYPE_EARLY_SKIP
6930 | OPTI_TYPE_NOT_ITERATED
6931 | OPTI_TYPE_APPENDED_SALT
6932 | OPTI_TYPE_RAW_HASH;
6933 dgst_pos0 = 0;
6934 dgst_pos1 = 3;
6935 dgst_pos2 = 2;
6936 dgst_pos3 = 1;
6937 break;
6938
6939 case 12: hash_type = HASH_TYPE_MD5;
6940 salt_type = SALT_TYPE_INTERN;
6941 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6942 opts_type = OPTS_TYPE_PT_GENERATE_LE
6943 | OPTS_TYPE_ST_ADD80
6944 | OPTS_TYPE_ST_ADDBITS14;
6945 kern_type = KERN_TYPE_MD5_PWSLT;
6946 dgst_size = DGST_SIZE_4_4;
6947 parse_func = postgresql_parse_hash;
6948 sort_by_digest = sort_by_digest_4_4;
6949 opti_type = OPTI_TYPE_ZERO_BYTE
6950 | OPTI_TYPE_PRECOMPUTE_INIT
6951 | OPTI_TYPE_PRECOMPUTE_MERKLE
6952 | OPTI_TYPE_MEET_IN_MIDDLE
6953 | OPTI_TYPE_EARLY_SKIP
6954 | OPTI_TYPE_NOT_ITERATED
6955 | OPTI_TYPE_APPENDED_SALT
6956 | OPTI_TYPE_RAW_HASH;
6957 dgst_pos0 = 0;
6958 dgst_pos1 = 3;
6959 dgst_pos2 = 2;
6960 dgst_pos3 = 1;
6961 break;
6962
6963 case 20: hash_type = HASH_TYPE_MD5;
6964 salt_type = SALT_TYPE_INTERN;
6965 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6966 opts_type = OPTS_TYPE_PT_GENERATE_LE
6967 | OPTS_TYPE_PT_ADD80
6968 | OPTS_TYPE_PT_ADDBITS14;
6969 kern_type = KERN_TYPE_MD5_SLTPW;
6970 dgst_size = DGST_SIZE_4_4;
6971 parse_func = md5s_parse_hash;
6972 sort_by_digest = sort_by_digest_4_4;
6973 opti_type = OPTI_TYPE_ZERO_BYTE
6974 | OPTI_TYPE_PRECOMPUTE_INIT
6975 | OPTI_TYPE_PRECOMPUTE_MERKLE
6976 | OPTI_TYPE_EARLY_SKIP
6977 | OPTI_TYPE_NOT_ITERATED
6978 | OPTI_TYPE_PREPENDED_SALT
6979 | OPTI_TYPE_RAW_HASH;
6980 dgst_pos0 = 0;
6981 dgst_pos1 = 3;
6982 dgst_pos2 = 2;
6983 dgst_pos3 = 1;
6984 break;
6985
6986 case 21: hash_type = HASH_TYPE_MD5;
6987 salt_type = SALT_TYPE_INTERN;
6988 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6989 opts_type = OPTS_TYPE_PT_GENERATE_LE
6990 | OPTS_TYPE_PT_ADD80
6991 | OPTS_TYPE_PT_ADDBITS14;
6992 kern_type = KERN_TYPE_MD5_SLTPW;
6993 dgst_size = DGST_SIZE_4_4;
6994 parse_func = osc_parse_hash;
6995 sort_by_digest = sort_by_digest_4_4;
6996 opti_type = OPTI_TYPE_ZERO_BYTE
6997 | OPTI_TYPE_PRECOMPUTE_INIT
6998 | OPTI_TYPE_PRECOMPUTE_MERKLE
6999 | OPTI_TYPE_EARLY_SKIP
7000 | OPTI_TYPE_NOT_ITERATED
7001 | OPTI_TYPE_PREPENDED_SALT
7002 | OPTI_TYPE_RAW_HASH;
7003 dgst_pos0 = 0;
7004 dgst_pos1 = 3;
7005 dgst_pos2 = 2;
7006 dgst_pos3 = 1;
7007 break;
7008
7009 case 22: hash_type = HASH_TYPE_MD5;
7010 salt_type = SALT_TYPE_EMBEDDED;
7011 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7012 opts_type = OPTS_TYPE_PT_GENERATE_LE
7013 | OPTS_TYPE_PT_ADD80
7014 | OPTS_TYPE_PT_ADDBITS14;
7015 kern_type = KERN_TYPE_MD5_SLTPW;
7016 dgst_size = DGST_SIZE_4_4;
7017 parse_func = netscreen_parse_hash;
7018 sort_by_digest = sort_by_digest_4_4;
7019 opti_type = OPTI_TYPE_ZERO_BYTE
7020 | OPTI_TYPE_PRECOMPUTE_INIT
7021 | OPTI_TYPE_PRECOMPUTE_MERKLE
7022 | OPTI_TYPE_EARLY_SKIP
7023 | OPTI_TYPE_NOT_ITERATED
7024 | OPTI_TYPE_PREPENDED_SALT
7025 | OPTI_TYPE_RAW_HASH;
7026 dgst_pos0 = 0;
7027 dgst_pos1 = 3;
7028 dgst_pos2 = 2;
7029 dgst_pos3 = 1;
7030 break;
7031
7032 case 23: hash_type = HASH_TYPE_MD5;
7033 salt_type = SALT_TYPE_EMBEDDED;
7034 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7035 opts_type = OPTS_TYPE_PT_GENERATE_LE
7036 | OPTS_TYPE_PT_ADD80
7037 | OPTS_TYPE_PT_ADDBITS14;
7038 kern_type = KERN_TYPE_MD5_SLTPW;
7039 dgst_size = DGST_SIZE_4_4;
7040 parse_func = skype_parse_hash;
7041 sort_by_digest = sort_by_digest_4_4;
7042 opti_type = OPTI_TYPE_ZERO_BYTE
7043 | OPTI_TYPE_PRECOMPUTE_INIT
7044 | OPTI_TYPE_PRECOMPUTE_MERKLE
7045 | OPTI_TYPE_EARLY_SKIP
7046 | OPTI_TYPE_NOT_ITERATED
7047 | OPTI_TYPE_PREPENDED_SALT
7048 | OPTI_TYPE_RAW_HASH;
7049 dgst_pos0 = 0;
7050 dgst_pos1 = 3;
7051 dgst_pos2 = 2;
7052 dgst_pos3 = 1;
7053 break;
7054
7055 case 30: hash_type = HASH_TYPE_MD5;
7056 salt_type = SALT_TYPE_INTERN;
7057 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7058 opts_type = OPTS_TYPE_PT_GENERATE_LE
7059 | OPTS_TYPE_PT_UNICODE
7060 | OPTS_TYPE_ST_ADD80
7061 | OPTS_TYPE_ST_ADDBITS14;
7062 kern_type = KERN_TYPE_MD5_PWUSLT;
7063 dgst_size = DGST_SIZE_4_4;
7064 parse_func = md5s_parse_hash;
7065 sort_by_digest = sort_by_digest_4_4;
7066 opti_type = OPTI_TYPE_ZERO_BYTE
7067 | OPTI_TYPE_PRECOMPUTE_INIT
7068 | OPTI_TYPE_PRECOMPUTE_MERKLE
7069 | OPTI_TYPE_MEET_IN_MIDDLE
7070 | OPTI_TYPE_EARLY_SKIP
7071 | OPTI_TYPE_NOT_ITERATED
7072 | OPTI_TYPE_APPENDED_SALT
7073 | OPTI_TYPE_RAW_HASH;
7074 dgst_pos0 = 0;
7075 dgst_pos1 = 3;
7076 dgst_pos2 = 2;
7077 dgst_pos3 = 1;
7078 break;
7079
7080 case 40: hash_type = HASH_TYPE_MD5;
7081 salt_type = SALT_TYPE_INTERN;
7082 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7083 opts_type = OPTS_TYPE_PT_GENERATE_LE
7084 | OPTS_TYPE_PT_ADD80
7085 | OPTS_TYPE_PT_ADDBITS14
7086 | OPTS_TYPE_PT_UNICODE;
7087 kern_type = KERN_TYPE_MD5_SLTPWU;
7088 dgst_size = DGST_SIZE_4_4;
7089 parse_func = md5s_parse_hash;
7090 sort_by_digest = sort_by_digest_4_4;
7091 opti_type = OPTI_TYPE_ZERO_BYTE
7092 | OPTI_TYPE_PRECOMPUTE_INIT
7093 | OPTI_TYPE_PRECOMPUTE_MERKLE
7094 | OPTI_TYPE_EARLY_SKIP
7095 | OPTI_TYPE_NOT_ITERATED
7096 | OPTI_TYPE_PREPENDED_SALT
7097 | OPTI_TYPE_RAW_HASH;
7098 dgst_pos0 = 0;
7099 dgst_pos1 = 3;
7100 dgst_pos2 = 2;
7101 dgst_pos3 = 1;
7102 break;
7103
7104 case 50: hash_type = HASH_TYPE_MD5;
7105 salt_type = SALT_TYPE_INTERN;
7106 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7107 opts_type = OPTS_TYPE_PT_GENERATE_LE
7108 | OPTS_TYPE_ST_ADD80
7109 | OPTS_TYPE_ST_ADDBITS14;
7110 kern_type = KERN_TYPE_HMACMD5_PW;
7111 dgst_size = DGST_SIZE_4_4;
7112 parse_func = hmacmd5_parse_hash;
7113 sort_by_digest = sort_by_digest_4_4;
7114 opti_type = OPTI_TYPE_ZERO_BYTE
7115 | OPTI_TYPE_NOT_ITERATED;
7116 dgst_pos0 = 0;
7117 dgst_pos1 = 3;
7118 dgst_pos2 = 2;
7119 dgst_pos3 = 1;
7120 break;
7121
7122 case 60: hash_type = HASH_TYPE_MD5;
7123 salt_type = SALT_TYPE_INTERN;
7124 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7125 opts_type = OPTS_TYPE_PT_GENERATE_LE
7126 | OPTS_TYPE_PT_ADD80
7127 | OPTS_TYPE_PT_ADDBITS14;
7128 kern_type = KERN_TYPE_HMACMD5_SLT;
7129 dgst_size = DGST_SIZE_4_4;
7130 parse_func = hmacmd5_parse_hash;
7131 sort_by_digest = sort_by_digest_4_4;
7132 opti_type = OPTI_TYPE_ZERO_BYTE
7133 | OPTI_TYPE_NOT_ITERATED;
7134 dgst_pos0 = 0;
7135 dgst_pos1 = 3;
7136 dgst_pos2 = 2;
7137 dgst_pos3 = 1;
7138 break;
7139
7140 case 100: hash_type = HASH_TYPE_SHA1;
7141 salt_type = SALT_TYPE_NONE;
7142 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7143 opts_type = OPTS_TYPE_PT_GENERATE_BE
7144 | OPTS_TYPE_PT_ADD80
7145 | OPTS_TYPE_PT_ADDBITS15;
7146 kern_type = KERN_TYPE_SHA1;
7147 dgst_size = DGST_SIZE_4_5;
7148 parse_func = sha1_parse_hash;
7149 sort_by_digest = sort_by_digest_4_5;
7150 opti_type = OPTI_TYPE_ZERO_BYTE
7151 | OPTI_TYPE_PRECOMPUTE_INIT
7152 | OPTI_TYPE_PRECOMPUTE_MERKLE
7153 | OPTI_TYPE_EARLY_SKIP
7154 | OPTI_TYPE_NOT_ITERATED
7155 | OPTI_TYPE_NOT_SALTED
7156 | OPTI_TYPE_RAW_HASH;
7157 dgst_pos0 = 3;
7158 dgst_pos1 = 4;
7159 dgst_pos2 = 2;
7160 dgst_pos3 = 1;
7161 break;
7162
7163 case 101: hash_type = HASH_TYPE_SHA1;
7164 salt_type = SALT_TYPE_NONE;
7165 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7166 opts_type = OPTS_TYPE_PT_GENERATE_BE
7167 | OPTS_TYPE_PT_ADD80
7168 | OPTS_TYPE_PT_ADDBITS15;
7169 kern_type = KERN_TYPE_SHA1;
7170 dgst_size = DGST_SIZE_4_5;
7171 parse_func = sha1b64_parse_hash;
7172 sort_by_digest = sort_by_digest_4_5;
7173 opti_type = OPTI_TYPE_ZERO_BYTE
7174 | OPTI_TYPE_PRECOMPUTE_INIT
7175 | OPTI_TYPE_PRECOMPUTE_MERKLE
7176 | OPTI_TYPE_EARLY_SKIP
7177 | OPTI_TYPE_NOT_ITERATED
7178 | OPTI_TYPE_NOT_SALTED
7179 | OPTI_TYPE_RAW_HASH;
7180 dgst_pos0 = 3;
7181 dgst_pos1 = 4;
7182 dgst_pos2 = 2;
7183 dgst_pos3 = 1;
7184 break;
7185
7186 case 110: hash_type = HASH_TYPE_SHA1;
7187 salt_type = SALT_TYPE_INTERN;
7188 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7189 opts_type = OPTS_TYPE_PT_GENERATE_BE
7190 | OPTS_TYPE_ST_ADD80
7191 | OPTS_TYPE_ST_ADDBITS15;
7192 kern_type = KERN_TYPE_SHA1_PWSLT;
7193 dgst_size = DGST_SIZE_4_5;
7194 parse_func = sha1s_parse_hash;
7195 sort_by_digest = sort_by_digest_4_5;
7196 opti_type = OPTI_TYPE_ZERO_BYTE
7197 | OPTI_TYPE_PRECOMPUTE_INIT
7198 | OPTI_TYPE_PRECOMPUTE_MERKLE
7199 | OPTI_TYPE_EARLY_SKIP
7200 | OPTI_TYPE_NOT_ITERATED
7201 | OPTI_TYPE_APPENDED_SALT
7202 | OPTI_TYPE_RAW_HASH;
7203 dgst_pos0 = 3;
7204 dgst_pos1 = 4;
7205 dgst_pos2 = 2;
7206 dgst_pos3 = 1;
7207 break;
7208
7209 case 111: hash_type = HASH_TYPE_SHA1;
7210 salt_type = SALT_TYPE_EMBEDDED;
7211 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7212 opts_type = OPTS_TYPE_PT_GENERATE_BE
7213 | OPTS_TYPE_ST_ADD80
7214 | OPTS_TYPE_ST_ADDBITS15;
7215 kern_type = KERN_TYPE_SHA1_PWSLT;
7216 dgst_size = DGST_SIZE_4_5;
7217 parse_func = sha1b64s_parse_hash;
7218 sort_by_digest = sort_by_digest_4_5;
7219 opti_type = OPTI_TYPE_ZERO_BYTE
7220 | OPTI_TYPE_PRECOMPUTE_INIT
7221 | OPTI_TYPE_PRECOMPUTE_MERKLE
7222 | OPTI_TYPE_EARLY_SKIP
7223 | OPTI_TYPE_NOT_ITERATED
7224 | OPTI_TYPE_APPENDED_SALT
7225 | OPTI_TYPE_RAW_HASH;
7226 dgst_pos0 = 3;
7227 dgst_pos1 = 4;
7228 dgst_pos2 = 2;
7229 dgst_pos3 = 1;
7230 break;
7231
7232 case 112: hash_type = HASH_TYPE_SHA1;
7233 salt_type = SALT_TYPE_INTERN;
7234 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7235 opts_type = OPTS_TYPE_PT_GENERATE_BE
7236 | OPTS_TYPE_ST_ADD80
7237 | OPTS_TYPE_ST_ADDBITS15
7238 | OPTS_TYPE_ST_HEX;
7239 kern_type = KERN_TYPE_SHA1_PWSLT;
7240 dgst_size = DGST_SIZE_4_5;
7241 parse_func = oracles_parse_hash;
7242 sort_by_digest = sort_by_digest_4_5;
7243 opti_type = OPTI_TYPE_ZERO_BYTE
7244 | OPTI_TYPE_PRECOMPUTE_INIT
7245 | OPTI_TYPE_PRECOMPUTE_MERKLE
7246 | OPTI_TYPE_EARLY_SKIP
7247 | OPTI_TYPE_NOT_ITERATED
7248 | OPTI_TYPE_APPENDED_SALT
7249 | OPTI_TYPE_RAW_HASH;
7250 dgst_pos0 = 3;
7251 dgst_pos1 = 4;
7252 dgst_pos2 = 2;
7253 dgst_pos3 = 1;
7254 break;
7255
7256 case 120: hash_type = HASH_TYPE_SHA1;
7257 salt_type = SALT_TYPE_INTERN;
7258 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7259 opts_type = OPTS_TYPE_PT_GENERATE_BE
7260 | OPTS_TYPE_PT_ADD80
7261 | OPTS_TYPE_PT_ADDBITS15;
7262 kern_type = KERN_TYPE_SHA1_SLTPW;
7263 dgst_size = DGST_SIZE_4_5;
7264 parse_func = sha1s_parse_hash;
7265 sort_by_digest = sort_by_digest_4_5;
7266 opti_type = OPTI_TYPE_ZERO_BYTE
7267 | OPTI_TYPE_PRECOMPUTE_INIT
7268 | OPTI_TYPE_PRECOMPUTE_MERKLE
7269 | OPTI_TYPE_EARLY_SKIP
7270 | OPTI_TYPE_NOT_ITERATED
7271 | OPTI_TYPE_PREPENDED_SALT
7272 | OPTI_TYPE_RAW_HASH;
7273 dgst_pos0 = 3;
7274 dgst_pos1 = 4;
7275 dgst_pos2 = 2;
7276 dgst_pos3 = 1;
7277 break;
7278
7279 case 121: hash_type = HASH_TYPE_SHA1;
7280 salt_type = SALT_TYPE_INTERN;
7281 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7282 opts_type = OPTS_TYPE_PT_GENERATE_BE
7283 | OPTS_TYPE_PT_ADD80
7284 | OPTS_TYPE_PT_ADDBITS15
7285 | OPTS_TYPE_ST_LOWER;
7286 kern_type = KERN_TYPE_SHA1_SLTPW;
7287 dgst_size = DGST_SIZE_4_5;
7288 parse_func = smf_parse_hash;
7289 sort_by_digest = sort_by_digest_4_5;
7290 opti_type = OPTI_TYPE_ZERO_BYTE
7291 | OPTI_TYPE_PRECOMPUTE_INIT
7292 | OPTI_TYPE_PRECOMPUTE_MERKLE
7293 | OPTI_TYPE_EARLY_SKIP
7294 | OPTI_TYPE_NOT_ITERATED
7295 | OPTI_TYPE_PREPENDED_SALT
7296 | OPTI_TYPE_RAW_HASH;
7297 dgst_pos0 = 3;
7298 dgst_pos1 = 4;
7299 dgst_pos2 = 2;
7300 dgst_pos3 = 1;
7301 break;
7302
7303 case 122: hash_type = HASH_TYPE_SHA1;
7304 salt_type = SALT_TYPE_EMBEDDED;
7305 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7306 opts_type = OPTS_TYPE_PT_GENERATE_BE
7307 | OPTS_TYPE_PT_ADD80
7308 | OPTS_TYPE_PT_ADDBITS15
7309 | OPTS_TYPE_ST_HEX;
7310 kern_type = KERN_TYPE_SHA1_SLTPW;
7311 dgst_size = DGST_SIZE_4_5;
7312 parse_func = osx1_parse_hash;
7313 sort_by_digest = sort_by_digest_4_5;
7314 opti_type = OPTI_TYPE_ZERO_BYTE
7315 | OPTI_TYPE_PRECOMPUTE_INIT
7316 | OPTI_TYPE_PRECOMPUTE_MERKLE
7317 | OPTI_TYPE_EARLY_SKIP
7318 | OPTI_TYPE_NOT_ITERATED
7319 | OPTI_TYPE_PREPENDED_SALT
7320 | OPTI_TYPE_RAW_HASH;
7321 dgst_pos0 = 3;
7322 dgst_pos1 = 4;
7323 dgst_pos2 = 2;
7324 dgst_pos3 = 1;
7325 break;
7326
7327 case 124: hash_type = HASH_TYPE_SHA1;
7328 salt_type = SALT_TYPE_EMBEDDED;
7329 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7330 opts_type = OPTS_TYPE_PT_GENERATE_BE
7331 | OPTS_TYPE_PT_ADD80
7332 | OPTS_TYPE_PT_ADDBITS15;
7333 kern_type = KERN_TYPE_SHA1_SLTPW;
7334 dgst_size = DGST_SIZE_4_5;
7335 parse_func = djangosha1_parse_hash;
7336 sort_by_digest = sort_by_digest_4_5;
7337 opti_type = OPTI_TYPE_ZERO_BYTE
7338 | OPTI_TYPE_PRECOMPUTE_INIT
7339 | OPTI_TYPE_PRECOMPUTE_MERKLE
7340 | OPTI_TYPE_EARLY_SKIP
7341 | OPTI_TYPE_NOT_ITERATED
7342 | OPTI_TYPE_PREPENDED_SALT
7343 | OPTI_TYPE_RAW_HASH;
7344 dgst_pos0 = 3;
7345 dgst_pos1 = 4;
7346 dgst_pos2 = 2;
7347 dgst_pos3 = 1;
7348 break;
7349
7350 case 125: hash_type = HASH_TYPE_SHA1;
7351 salt_type = SALT_TYPE_EMBEDDED;
7352 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7353 opts_type = OPTS_TYPE_PT_GENERATE_BE
7354 | OPTS_TYPE_PT_ADD80
7355 | OPTS_TYPE_PT_ADDBITS15
7356 | OPTS_TYPE_ST_HEX;
7357 kern_type = KERN_TYPE_SHA1_SLTPW;
7358 dgst_size = DGST_SIZE_4_5;
7359 parse_func = arubaos_parse_hash;
7360 sort_by_digest = sort_by_digest_4_5;
7361 opti_type = OPTI_TYPE_ZERO_BYTE
7362 | OPTI_TYPE_PRECOMPUTE_INIT
7363 | OPTI_TYPE_PRECOMPUTE_MERKLE
7364 | OPTI_TYPE_EARLY_SKIP
7365 | OPTI_TYPE_NOT_ITERATED
7366 | OPTI_TYPE_PREPENDED_SALT
7367 | OPTI_TYPE_RAW_HASH;
7368 dgst_pos0 = 3;
7369 dgst_pos1 = 4;
7370 dgst_pos2 = 2;
7371 dgst_pos3 = 1;
7372 break;
7373
7374 case 130: hash_type = HASH_TYPE_SHA1;
7375 salt_type = SALT_TYPE_INTERN;
7376 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7377 opts_type = OPTS_TYPE_PT_GENERATE_BE
7378 | OPTS_TYPE_PT_UNICODE
7379 | OPTS_TYPE_ST_ADD80
7380 | OPTS_TYPE_ST_ADDBITS15;
7381 kern_type = KERN_TYPE_SHA1_PWUSLT;
7382 dgst_size = DGST_SIZE_4_5;
7383 parse_func = sha1s_parse_hash;
7384 sort_by_digest = sort_by_digest_4_5;
7385 opti_type = OPTI_TYPE_ZERO_BYTE
7386 | OPTI_TYPE_PRECOMPUTE_INIT
7387 | OPTI_TYPE_PRECOMPUTE_MERKLE
7388 | OPTI_TYPE_EARLY_SKIP
7389 | OPTI_TYPE_NOT_ITERATED
7390 | OPTI_TYPE_APPENDED_SALT
7391 | OPTI_TYPE_RAW_HASH;
7392 dgst_pos0 = 3;
7393 dgst_pos1 = 4;
7394 dgst_pos2 = 2;
7395 dgst_pos3 = 1;
7396 break;
7397
7398 case 131: hash_type = HASH_TYPE_SHA1;
7399 salt_type = SALT_TYPE_EMBEDDED;
7400 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7401 opts_type = OPTS_TYPE_PT_GENERATE_BE
7402 | OPTS_TYPE_PT_UNICODE
7403 | OPTS_TYPE_PT_UPPER
7404 | OPTS_TYPE_ST_ADD80
7405 | OPTS_TYPE_ST_ADDBITS15
7406 | OPTS_TYPE_ST_HEX;
7407 kern_type = KERN_TYPE_SHA1_PWUSLT;
7408 dgst_size = DGST_SIZE_4_5;
7409 parse_func = mssql2000_parse_hash;
7410 sort_by_digest = sort_by_digest_4_5;
7411 opti_type = OPTI_TYPE_ZERO_BYTE
7412 | OPTI_TYPE_PRECOMPUTE_INIT
7413 | OPTI_TYPE_PRECOMPUTE_MERKLE
7414 | OPTI_TYPE_EARLY_SKIP
7415 | OPTI_TYPE_NOT_ITERATED
7416 | OPTI_TYPE_APPENDED_SALT
7417 | OPTI_TYPE_RAW_HASH;
7418 dgst_pos0 = 3;
7419 dgst_pos1 = 4;
7420 dgst_pos2 = 2;
7421 dgst_pos3 = 1;
7422 break;
7423
7424 case 132: hash_type = HASH_TYPE_SHA1;
7425 salt_type = SALT_TYPE_EMBEDDED;
7426 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7427 opts_type = OPTS_TYPE_PT_GENERATE_BE
7428 | OPTS_TYPE_PT_UNICODE
7429 | OPTS_TYPE_ST_ADD80
7430 | OPTS_TYPE_ST_ADDBITS15
7431 | OPTS_TYPE_ST_HEX;
7432 kern_type = KERN_TYPE_SHA1_PWUSLT;
7433 dgst_size = DGST_SIZE_4_5;
7434 parse_func = mssql2005_parse_hash;
7435 sort_by_digest = sort_by_digest_4_5;
7436 opti_type = OPTI_TYPE_ZERO_BYTE
7437 | OPTI_TYPE_PRECOMPUTE_INIT
7438 | OPTI_TYPE_PRECOMPUTE_MERKLE
7439 | OPTI_TYPE_EARLY_SKIP
7440 | OPTI_TYPE_NOT_ITERATED
7441 | OPTI_TYPE_APPENDED_SALT
7442 | OPTI_TYPE_RAW_HASH;
7443 dgst_pos0 = 3;
7444 dgst_pos1 = 4;
7445 dgst_pos2 = 2;
7446 dgst_pos3 = 1;
7447 break;
7448
7449 case 133: hash_type = HASH_TYPE_SHA1;
7450 salt_type = SALT_TYPE_EMBEDDED;
7451 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7452 opts_type = OPTS_TYPE_PT_GENERATE_BE
7453 | OPTS_TYPE_PT_UNICODE
7454 | OPTS_TYPE_ST_ADD80
7455 | OPTS_TYPE_ST_ADDBITS15;
7456 kern_type = KERN_TYPE_SHA1_PWUSLT;
7457 dgst_size = DGST_SIZE_4_5;
7458 parse_func = peoplesoft_parse_hash;
7459 sort_by_digest = sort_by_digest_4_5;
7460 opti_type = OPTI_TYPE_ZERO_BYTE
7461 | OPTI_TYPE_PRECOMPUTE_INIT
7462 | OPTI_TYPE_PRECOMPUTE_MERKLE
7463 | OPTI_TYPE_EARLY_SKIP
7464 | OPTI_TYPE_NOT_ITERATED
7465 | OPTI_TYPE_APPENDED_SALT
7466 | OPTI_TYPE_RAW_HASH;
7467 dgst_pos0 = 3;
7468 dgst_pos1 = 4;
7469 dgst_pos2 = 2;
7470 dgst_pos3 = 1;
7471 break;
7472
7473 case 140: hash_type = HASH_TYPE_SHA1;
7474 salt_type = SALT_TYPE_INTERN;
7475 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7476 opts_type = OPTS_TYPE_PT_GENERATE_BE
7477 | OPTS_TYPE_PT_ADD80
7478 | OPTS_TYPE_PT_ADDBITS15
7479 | OPTS_TYPE_PT_UNICODE;
7480 kern_type = KERN_TYPE_SHA1_SLTPWU;
7481 dgst_size = DGST_SIZE_4_5;
7482 parse_func = sha1s_parse_hash;
7483 sort_by_digest = sort_by_digest_4_5;
7484 opti_type = OPTI_TYPE_ZERO_BYTE
7485 | OPTI_TYPE_PRECOMPUTE_INIT
7486 | OPTI_TYPE_PRECOMPUTE_MERKLE
7487 | OPTI_TYPE_EARLY_SKIP
7488 | OPTI_TYPE_NOT_ITERATED
7489 | OPTI_TYPE_PREPENDED_SALT
7490 | OPTI_TYPE_RAW_HASH;
7491 dgst_pos0 = 3;
7492 dgst_pos1 = 4;
7493 dgst_pos2 = 2;
7494 dgst_pos3 = 1;
7495 break;
7496
7497 case 141: hash_type = HASH_TYPE_SHA1;
7498 salt_type = SALT_TYPE_EMBEDDED;
7499 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7500 opts_type = OPTS_TYPE_PT_GENERATE_BE
7501 | OPTS_TYPE_PT_ADD80
7502 | OPTS_TYPE_PT_ADDBITS15
7503 | OPTS_TYPE_PT_UNICODE
7504 | OPTS_TYPE_ST_BASE64;
7505 kern_type = KERN_TYPE_SHA1_SLTPWU;
7506 dgst_size = DGST_SIZE_4_5;
7507 parse_func = episerver_parse_hash;
7508 sort_by_digest = sort_by_digest_4_5;
7509 opti_type = OPTI_TYPE_ZERO_BYTE
7510 | OPTI_TYPE_PRECOMPUTE_INIT
7511 | OPTI_TYPE_PRECOMPUTE_MERKLE
7512 | OPTI_TYPE_EARLY_SKIP
7513 | OPTI_TYPE_NOT_ITERATED
7514 | OPTI_TYPE_PREPENDED_SALT
7515 | OPTI_TYPE_RAW_HASH;
7516 dgst_pos0 = 3;
7517 dgst_pos1 = 4;
7518 dgst_pos2 = 2;
7519 dgst_pos3 = 1;
7520 break;
7521
7522 case 150: hash_type = HASH_TYPE_SHA1;
7523 salt_type = SALT_TYPE_INTERN;
7524 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7525 opts_type = OPTS_TYPE_PT_GENERATE_BE
7526 | OPTS_TYPE_ST_ADD80
7527 | OPTS_TYPE_ST_ADDBITS15;
7528 kern_type = KERN_TYPE_HMACSHA1_PW;
7529 dgst_size = DGST_SIZE_4_5;
7530 parse_func = hmacsha1_parse_hash;
7531 sort_by_digest = sort_by_digest_4_5;
7532 opti_type = OPTI_TYPE_ZERO_BYTE
7533 | OPTI_TYPE_NOT_ITERATED;
7534 dgst_pos0 = 3;
7535 dgst_pos1 = 4;
7536 dgst_pos2 = 2;
7537 dgst_pos3 = 1;
7538 break;
7539
7540 case 160: hash_type = HASH_TYPE_SHA1;
7541 salt_type = SALT_TYPE_INTERN;
7542 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7543 opts_type = OPTS_TYPE_PT_GENERATE_BE
7544 | OPTS_TYPE_PT_ADD80
7545 | OPTS_TYPE_PT_ADDBITS15;
7546 kern_type = KERN_TYPE_HMACSHA1_SLT;
7547 dgst_size = DGST_SIZE_4_5;
7548 parse_func = hmacsha1_parse_hash;
7549 sort_by_digest = sort_by_digest_4_5;
7550 opti_type = OPTI_TYPE_ZERO_BYTE
7551 | OPTI_TYPE_NOT_ITERATED;
7552 dgst_pos0 = 3;
7553 dgst_pos1 = 4;
7554 dgst_pos2 = 2;
7555 dgst_pos3 = 1;
7556 break;
7557
7558 case 190: hash_type = HASH_TYPE_SHA1;
7559 salt_type = SALT_TYPE_NONE;
7560 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7561 opts_type = OPTS_TYPE_PT_GENERATE_BE
7562 | OPTS_TYPE_PT_ADD80
7563 | OPTS_TYPE_PT_ADDBITS15;
7564 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7565 dgst_size = DGST_SIZE_4_5;
7566 parse_func = sha1linkedin_parse_hash;
7567 sort_by_digest = sort_by_digest_4_5;
7568 opti_type = OPTI_TYPE_ZERO_BYTE
7569 | OPTI_TYPE_PRECOMPUTE_INIT
7570 | OPTI_TYPE_EARLY_SKIP
7571 | OPTI_TYPE_NOT_ITERATED
7572 | OPTI_TYPE_NOT_SALTED;
7573 dgst_pos0 = 0;
7574 dgst_pos1 = 4;
7575 dgst_pos2 = 3;
7576 dgst_pos3 = 2;
7577 break;
7578
7579 case 200: hash_type = HASH_TYPE_MYSQL;
7580 salt_type = SALT_TYPE_NONE;
7581 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7582 opts_type = 0;
7583 kern_type = KERN_TYPE_MYSQL;
7584 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7585 parse_func = mysql323_parse_hash;
7586 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7587 opti_type = OPTI_TYPE_ZERO_BYTE;
7588 dgst_pos0 = 0;
7589 dgst_pos1 = 1;
7590 dgst_pos2 = 2;
7591 dgst_pos3 = 3;
7592 break;
7593
7594 case 300: hash_type = HASH_TYPE_SHA1;
7595 salt_type = SALT_TYPE_NONE;
7596 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7597 opts_type = OPTS_TYPE_PT_GENERATE_BE
7598 | OPTS_TYPE_PT_ADD80
7599 | OPTS_TYPE_PT_ADDBITS15;
7600 kern_type = KERN_TYPE_MYSQL41;
7601 dgst_size = DGST_SIZE_4_5;
7602 parse_func = sha1_parse_hash;
7603 sort_by_digest = sort_by_digest_4_5;
7604 opti_type = OPTI_TYPE_ZERO_BYTE
7605 | OPTI_TYPE_PRECOMPUTE_INIT
7606 | OPTI_TYPE_PRECOMPUTE_MERKLE
7607 | OPTI_TYPE_EARLY_SKIP
7608 | OPTI_TYPE_NOT_ITERATED
7609 | OPTI_TYPE_NOT_SALTED;
7610 dgst_pos0 = 3;
7611 dgst_pos1 = 4;
7612 dgst_pos2 = 2;
7613 dgst_pos3 = 1;
7614 break;
7615
7616 case 400: hash_type = HASH_TYPE_MD5;
7617 salt_type = SALT_TYPE_EMBEDDED;
7618 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7619 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7620 kern_type = KERN_TYPE_PHPASS;
7621 dgst_size = DGST_SIZE_4_4;
7622 parse_func = phpass_parse_hash;
7623 sort_by_digest = sort_by_digest_4_4;
7624 opti_type = OPTI_TYPE_ZERO_BYTE
7625 | OPTI_TYPE_SLOW_HASH_SIMD;
7626 dgst_pos0 = 0;
7627 dgst_pos1 = 1;
7628 dgst_pos2 = 2;
7629 dgst_pos3 = 3;
7630 break;
7631
7632 case 500: hash_type = HASH_TYPE_MD5;
7633 salt_type = SALT_TYPE_EMBEDDED;
7634 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7635 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7636 kern_type = KERN_TYPE_MD5CRYPT;
7637 dgst_size = DGST_SIZE_4_4;
7638 parse_func = md5crypt_parse_hash;
7639 sort_by_digest = sort_by_digest_4_4;
7640 opti_type = OPTI_TYPE_ZERO_BYTE;
7641 dgst_pos0 = 0;
7642 dgst_pos1 = 1;
7643 dgst_pos2 = 2;
7644 dgst_pos3 = 3;
7645 break;
7646
7647 case 501: hash_type = HASH_TYPE_MD5;
7648 salt_type = SALT_TYPE_EMBEDDED;
7649 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7650 opts_type = OPTS_TYPE_PT_GENERATE_LE
7651 | OPTS_TYPE_HASH_COPY;
7652 kern_type = KERN_TYPE_MD5CRYPT;
7653 dgst_size = DGST_SIZE_4_4;
7654 parse_func = juniper_parse_hash;
7655 sort_by_digest = sort_by_digest_4_4;
7656 opti_type = OPTI_TYPE_ZERO_BYTE;
7657 dgst_pos0 = 0;
7658 dgst_pos1 = 1;
7659 dgst_pos2 = 2;
7660 dgst_pos3 = 3;
7661 break;
7662
7663 case 900: hash_type = HASH_TYPE_MD4;
7664 salt_type = SALT_TYPE_NONE;
7665 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7666 opts_type = OPTS_TYPE_PT_GENERATE_LE
7667 | OPTS_TYPE_PT_ADD80
7668 | OPTS_TYPE_PT_ADDBITS14;
7669 kern_type = KERN_TYPE_MD4;
7670 dgst_size = DGST_SIZE_4_4;
7671 parse_func = md4_parse_hash;
7672 sort_by_digest = sort_by_digest_4_4;
7673 opti_type = OPTI_TYPE_ZERO_BYTE
7674 | OPTI_TYPE_PRECOMPUTE_INIT
7675 | OPTI_TYPE_PRECOMPUTE_MERKLE
7676 | OPTI_TYPE_MEET_IN_MIDDLE
7677 | OPTI_TYPE_EARLY_SKIP
7678 | OPTI_TYPE_NOT_ITERATED
7679 | OPTI_TYPE_NOT_SALTED
7680 | OPTI_TYPE_RAW_HASH;
7681 dgst_pos0 = 0;
7682 dgst_pos1 = 3;
7683 dgst_pos2 = 2;
7684 dgst_pos3 = 1;
7685 break;
7686
7687 case 1000: hash_type = HASH_TYPE_MD4;
7688 salt_type = SALT_TYPE_NONE;
7689 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7690 opts_type = OPTS_TYPE_PT_GENERATE_LE
7691 | OPTS_TYPE_PT_ADD80
7692 | OPTS_TYPE_PT_ADDBITS14
7693 | OPTS_TYPE_PT_UNICODE;
7694 kern_type = KERN_TYPE_MD4_PWU;
7695 dgst_size = DGST_SIZE_4_4;
7696 parse_func = md4_parse_hash;
7697 sort_by_digest = sort_by_digest_4_4;
7698 opti_type = OPTI_TYPE_ZERO_BYTE
7699 | OPTI_TYPE_PRECOMPUTE_INIT
7700 | OPTI_TYPE_PRECOMPUTE_MERKLE
7701 | OPTI_TYPE_MEET_IN_MIDDLE
7702 | OPTI_TYPE_EARLY_SKIP
7703 | OPTI_TYPE_NOT_ITERATED
7704 | OPTI_TYPE_NOT_SALTED
7705 | OPTI_TYPE_RAW_HASH;
7706 dgst_pos0 = 0;
7707 dgst_pos1 = 3;
7708 dgst_pos2 = 2;
7709 dgst_pos3 = 1;
7710 break;
7711
7712 case 1100: hash_type = HASH_TYPE_MD4;
7713 salt_type = SALT_TYPE_INTERN;
7714 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7715 opts_type = OPTS_TYPE_PT_GENERATE_LE
7716 | OPTS_TYPE_PT_ADD80
7717 | OPTS_TYPE_PT_ADDBITS14
7718 | OPTS_TYPE_PT_UNICODE
7719 | OPTS_TYPE_ST_ADD80
7720 | OPTS_TYPE_ST_UNICODE
7721 | OPTS_TYPE_ST_LOWER;
7722 kern_type = KERN_TYPE_MD44_PWUSLT;
7723 dgst_size = DGST_SIZE_4_4;
7724 parse_func = dcc_parse_hash;
7725 sort_by_digest = sort_by_digest_4_4;
7726 opti_type = OPTI_TYPE_ZERO_BYTE
7727 | OPTI_TYPE_PRECOMPUTE_INIT
7728 | OPTI_TYPE_PRECOMPUTE_MERKLE
7729 | OPTI_TYPE_EARLY_SKIP
7730 | OPTI_TYPE_NOT_ITERATED;
7731 dgst_pos0 = 0;
7732 dgst_pos1 = 3;
7733 dgst_pos2 = 2;
7734 dgst_pos3 = 1;
7735 break;
7736
7737 case 1400: hash_type = HASH_TYPE_SHA256;
7738 salt_type = SALT_TYPE_NONE;
7739 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7740 opts_type = OPTS_TYPE_PT_GENERATE_BE
7741 | OPTS_TYPE_PT_ADD80
7742 | OPTS_TYPE_PT_ADDBITS15;
7743 kern_type = KERN_TYPE_SHA256;
7744 dgst_size = DGST_SIZE_4_8;
7745 parse_func = sha256_parse_hash;
7746 sort_by_digest = sort_by_digest_4_8;
7747 opti_type = OPTI_TYPE_ZERO_BYTE
7748 | OPTI_TYPE_PRECOMPUTE_INIT
7749 | OPTI_TYPE_PRECOMPUTE_MERKLE
7750 | OPTI_TYPE_EARLY_SKIP
7751 | OPTI_TYPE_NOT_ITERATED
7752 | OPTI_TYPE_NOT_SALTED
7753 | OPTI_TYPE_RAW_HASH;
7754 dgst_pos0 = 3;
7755 dgst_pos1 = 7;
7756 dgst_pos2 = 2;
7757 dgst_pos3 = 6;
7758 break;
7759
7760 case 1410: hash_type = HASH_TYPE_SHA256;
7761 salt_type = SALT_TYPE_INTERN;
7762 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7763 opts_type = OPTS_TYPE_PT_GENERATE_BE
7764 | OPTS_TYPE_ST_ADD80
7765 | OPTS_TYPE_ST_ADDBITS15;
7766 kern_type = KERN_TYPE_SHA256_PWSLT;
7767 dgst_size = DGST_SIZE_4_8;
7768 parse_func = sha256s_parse_hash;
7769 sort_by_digest = sort_by_digest_4_8;
7770 opti_type = OPTI_TYPE_ZERO_BYTE
7771 | OPTI_TYPE_PRECOMPUTE_INIT
7772 | OPTI_TYPE_PRECOMPUTE_MERKLE
7773 | OPTI_TYPE_EARLY_SKIP
7774 | OPTI_TYPE_NOT_ITERATED
7775 | OPTI_TYPE_APPENDED_SALT
7776 | OPTI_TYPE_RAW_HASH;
7777 dgst_pos0 = 3;
7778 dgst_pos1 = 7;
7779 dgst_pos2 = 2;
7780 dgst_pos3 = 6;
7781 break;
7782
7783 case 1420: hash_type = HASH_TYPE_SHA256;
7784 salt_type = SALT_TYPE_INTERN;
7785 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7786 opts_type = OPTS_TYPE_PT_GENERATE_BE
7787 | OPTS_TYPE_PT_ADD80
7788 | OPTS_TYPE_PT_ADDBITS15;
7789 kern_type = KERN_TYPE_SHA256_SLTPW;
7790 dgst_size = DGST_SIZE_4_8;
7791 parse_func = sha256s_parse_hash;
7792 sort_by_digest = sort_by_digest_4_8;
7793 opti_type = OPTI_TYPE_ZERO_BYTE
7794 | OPTI_TYPE_PRECOMPUTE_INIT
7795 | OPTI_TYPE_PRECOMPUTE_MERKLE
7796 | OPTI_TYPE_EARLY_SKIP
7797 | OPTI_TYPE_NOT_ITERATED
7798 | OPTI_TYPE_PREPENDED_SALT
7799 | OPTI_TYPE_RAW_HASH;
7800 dgst_pos0 = 3;
7801 dgst_pos1 = 7;
7802 dgst_pos2 = 2;
7803 dgst_pos3 = 6;
7804 break;
7805
7806 case 1421: hash_type = HASH_TYPE_SHA256;
7807 salt_type = SALT_TYPE_EMBEDDED;
7808 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7809 opts_type = OPTS_TYPE_PT_GENERATE_BE
7810 | OPTS_TYPE_PT_ADD80
7811 | OPTS_TYPE_PT_ADDBITS15;
7812 kern_type = KERN_TYPE_SHA256_SLTPW;
7813 dgst_size = DGST_SIZE_4_8;
7814 parse_func = hmailserver_parse_hash;
7815 sort_by_digest = sort_by_digest_4_8;
7816 opti_type = OPTI_TYPE_ZERO_BYTE
7817 | OPTI_TYPE_PRECOMPUTE_INIT
7818 | OPTI_TYPE_PRECOMPUTE_MERKLE
7819 | OPTI_TYPE_EARLY_SKIP
7820 | OPTI_TYPE_NOT_ITERATED
7821 | OPTI_TYPE_PREPENDED_SALT
7822 | OPTI_TYPE_RAW_HASH;
7823 dgst_pos0 = 3;
7824 dgst_pos1 = 7;
7825 dgst_pos2 = 2;
7826 dgst_pos3 = 6;
7827 break;
7828
7829 case 1430: hash_type = HASH_TYPE_SHA256;
7830 salt_type = SALT_TYPE_INTERN;
7831 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7832 opts_type = OPTS_TYPE_PT_GENERATE_BE
7833 | OPTS_TYPE_PT_UNICODE
7834 | OPTS_TYPE_ST_ADD80
7835 | OPTS_TYPE_ST_ADDBITS15;
7836 kern_type = KERN_TYPE_SHA256_PWUSLT;
7837 dgst_size = DGST_SIZE_4_8;
7838 parse_func = sha256s_parse_hash;
7839 sort_by_digest = sort_by_digest_4_8;
7840 opti_type = OPTI_TYPE_ZERO_BYTE
7841 | OPTI_TYPE_PRECOMPUTE_INIT
7842 | OPTI_TYPE_PRECOMPUTE_MERKLE
7843 | OPTI_TYPE_EARLY_SKIP
7844 | OPTI_TYPE_NOT_ITERATED
7845 | OPTI_TYPE_APPENDED_SALT
7846 | OPTI_TYPE_RAW_HASH;
7847 dgst_pos0 = 3;
7848 dgst_pos1 = 7;
7849 dgst_pos2 = 2;
7850 dgst_pos3 = 6;
7851 break;
7852
7853 case 1440: hash_type = HASH_TYPE_SHA256;
7854 salt_type = SALT_TYPE_INTERN;
7855 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7856 opts_type = OPTS_TYPE_PT_GENERATE_BE
7857 | OPTS_TYPE_PT_ADD80
7858 | OPTS_TYPE_PT_ADDBITS15
7859 | OPTS_TYPE_PT_UNICODE;
7860 kern_type = KERN_TYPE_SHA256_SLTPWU;
7861 dgst_size = DGST_SIZE_4_8;
7862 parse_func = sha256s_parse_hash;
7863 sort_by_digest = sort_by_digest_4_8;
7864 opti_type = OPTI_TYPE_ZERO_BYTE
7865 | OPTI_TYPE_PRECOMPUTE_INIT
7866 | OPTI_TYPE_PRECOMPUTE_MERKLE
7867 | OPTI_TYPE_EARLY_SKIP
7868 | OPTI_TYPE_NOT_ITERATED
7869 | OPTI_TYPE_PREPENDED_SALT
7870 | OPTI_TYPE_RAW_HASH;
7871 dgst_pos0 = 3;
7872 dgst_pos1 = 7;
7873 dgst_pos2 = 2;
7874 dgst_pos3 = 6;
7875 break;
7876
7877 case 1441: hash_type = HASH_TYPE_SHA256;
7878 salt_type = SALT_TYPE_EMBEDDED;
7879 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7880 opts_type = OPTS_TYPE_PT_GENERATE_BE
7881 | OPTS_TYPE_PT_ADD80
7882 | OPTS_TYPE_PT_ADDBITS15
7883 | OPTS_TYPE_PT_UNICODE
7884 | OPTS_TYPE_ST_BASE64;
7885 kern_type = KERN_TYPE_SHA256_SLTPWU;
7886 dgst_size = DGST_SIZE_4_8;
7887 parse_func = episerver4_parse_hash;
7888 sort_by_digest = sort_by_digest_4_8;
7889 opti_type = OPTI_TYPE_ZERO_BYTE
7890 | OPTI_TYPE_PRECOMPUTE_INIT
7891 | OPTI_TYPE_PRECOMPUTE_MERKLE
7892 | OPTI_TYPE_EARLY_SKIP
7893 | OPTI_TYPE_NOT_ITERATED
7894 | OPTI_TYPE_PREPENDED_SALT
7895 | OPTI_TYPE_RAW_HASH;
7896 dgst_pos0 = 3;
7897 dgst_pos1 = 7;
7898 dgst_pos2 = 2;
7899 dgst_pos3 = 6;
7900 break;
7901
7902 case 1450: hash_type = HASH_TYPE_SHA256;
7903 salt_type = SALT_TYPE_INTERN;
7904 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7905 opts_type = OPTS_TYPE_PT_GENERATE_BE
7906 | OPTS_TYPE_ST_ADD80;
7907 kern_type = KERN_TYPE_HMACSHA256_PW;
7908 dgst_size = DGST_SIZE_4_8;
7909 parse_func = hmacsha256_parse_hash;
7910 sort_by_digest = sort_by_digest_4_8;
7911 opti_type = OPTI_TYPE_ZERO_BYTE
7912 | OPTI_TYPE_NOT_ITERATED;
7913 dgst_pos0 = 3;
7914 dgst_pos1 = 7;
7915 dgst_pos2 = 2;
7916 dgst_pos3 = 6;
7917 break;
7918
7919 case 1460: hash_type = HASH_TYPE_SHA256;
7920 salt_type = SALT_TYPE_INTERN;
7921 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7922 opts_type = OPTS_TYPE_PT_GENERATE_BE
7923 | OPTS_TYPE_PT_ADD80
7924 | OPTS_TYPE_PT_ADDBITS15;
7925 kern_type = KERN_TYPE_HMACSHA256_SLT;
7926 dgst_size = DGST_SIZE_4_8;
7927 parse_func = hmacsha256_parse_hash;
7928 sort_by_digest = sort_by_digest_4_8;
7929 opti_type = OPTI_TYPE_ZERO_BYTE
7930 | OPTI_TYPE_NOT_ITERATED;
7931 dgst_pos0 = 3;
7932 dgst_pos1 = 7;
7933 dgst_pos2 = 2;
7934 dgst_pos3 = 6;
7935 break;
7936
7937 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7938 salt_type = SALT_TYPE_EMBEDDED;
7939 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7940 opts_type = OPTS_TYPE_PT_GENERATE_LE
7941 | OPTS_TYPE_PT_BITSLICE;
7942 kern_type = KERN_TYPE_DESCRYPT;
7943 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7944 parse_func = descrypt_parse_hash;
7945 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7946 opti_type = OPTI_TYPE_ZERO_BYTE
7947 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7948 dgst_pos0 = 0;
7949 dgst_pos1 = 1;
7950 dgst_pos2 = 2;
7951 dgst_pos3 = 3;
7952 break;
7953
7954 case 1600: hash_type = HASH_TYPE_MD5;
7955 salt_type = SALT_TYPE_EMBEDDED;
7956 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7957 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7958 kern_type = KERN_TYPE_APR1CRYPT;
7959 dgst_size = DGST_SIZE_4_4;
7960 parse_func = md5apr1_parse_hash;
7961 sort_by_digest = sort_by_digest_4_4;
7962 opti_type = OPTI_TYPE_ZERO_BYTE;
7963 dgst_pos0 = 0;
7964 dgst_pos1 = 1;
7965 dgst_pos2 = 2;
7966 dgst_pos3 = 3;
7967 break;
7968
7969 case 1700: hash_type = HASH_TYPE_SHA512;
7970 salt_type = SALT_TYPE_NONE;
7971 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7972 opts_type = OPTS_TYPE_PT_GENERATE_BE
7973 | OPTS_TYPE_PT_ADD80
7974 | OPTS_TYPE_PT_ADDBITS15;
7975 kern_type = KERN_TYPE_SHA512;
7976 dgst_size = DGST_SIZE_8_8;
7977 parse_func = sha512_parse_hash;
7978 sort_by_digest = sort_by_digest_8_8;
7979 opti_type = OPTI_TYPE_ZERO_BYTE
7980 | OPTI_TYPE_PRECOMPUTE_INIT
7981 | OPTI_TYPE_PRECOMPUTE_MERKLE
7982 | OPTI_TYPE_EARLY_SKIP
7983 | OPTI_TYPE_NOT_ITERATED
7984 | OPTI_TYPE_NOT_SALTED
7985 | OPTI_TYPE_USES_BITS_64
7986 | OPTI_TYPE_RAW_HASH;
7987 dgst_pos0 = 14;
7988 dgst_pos1 = 15;
7989 dgst_pos2 = 6;
7990 dgst_pos3 = 7;
7991 break;
7992
7993 case 1710: hash_type = HASH_TYPE_SHA512;
7994 salt_type = SALT_TYPE_INTERN;
7995 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7996 opts_type = OPTS_TYPE_PT_GENERATE_BE
7997 | OPTS_TYPE_ST_ADD80
7998 | OPTS_TYPE_ST_ADDBITS15;
7999 kern_type = KERN_TYPE_SHA512_PWSLT;
8000 dgst_size = DGST_SIZE_8_8;
8001 parse_func = sha512s_parse_hash;
8002 sort_by_digest = sort_by_digest_8_8;
8003 opti_type = OPTI_TYPE_ZERO_BYTE
8004 | OPTI_TYPE_PRECOMPUTE_INIT
8005 | OPTI_TYPE_PRECOMPUTE_MERKLE
8006 | OPTI_TYPE_EARLY_SKIP
8007 | OPTI_TYPE_NOT_ITERATED
8008 | OPTI_TYPE_APPENDED_SALT
8009 | OPTI_TYPE_USES_BITS_64
8010 | OPTI_TYPE_RAW_HASH;
8011 dgst_pos0 = 14;
8012 dgst_pos1 = 15;
8013 dgst_pos2 = 6;
8014 dgst_pos3 = 7;
8015 break;
8016
8017 case 1711: hash_type = HASH_TYPE_SHA512;
8018 salt_type = SALT_TYPE_EMBEDDED;
8019 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8020 opts_type = OPTS_TYPE_PT_GENERATE_BE
8021 | OPTS_TYPE_ST_ADD80
8022 | OPTS_TYPE_ST_ADDBITS15;
8023 kern_type = KERN_TYPE_SHA512_PWSLT;
8024 dgst_size = DGST_SIZE_8_8;
8025 parse_func = sha512b64s_parse_hash;
8026 sort_by_digest = sort_by_digest_8_8;
8027 opti_type = OPTI_TYPE_ZERO_BYTE
8028 | OPTI_TYPE_PRECOMPUTE_INIT
8029 | OPTI_TYPE_PRECOMPUTE_MERKLE
8030 | OPTI_TYPE_EARLY_SKIP
8031 | OPTI_TYPE_NOT_ITERATED
8032 | OPTI_TYPE_APPENDED_SALT
8033 | OPTI_TYPE_USES_BITS_64
8034 | OPTI_TYPE_RAW_HASH;
8035 dgst_pos0 = 14;
8036 dgst_pos1 = 15;
8037 dgst_pos2 = 6;
8038 dgst_pos3 = 7;
8039 break;
8040
8041 case 1720: hash_type = HASH_TYPE_SHA512;
8042 salt_type = SALT_TYPE_INTERN;
8043 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8044 opts_type = OPTS_TYPE_PT_GENERATE_BE
8045 | OPTS_TYPE_PT_ADD80
8046 | OPTS_TYPE_PT_ADDBITS15;
8047 kern_type = KERN_TYPE_SHA512_SLTPW;
8048 dgst_size = DGST_SIZE_8_8;
8049 parse_func = sha512s_parse_hash;
8050 sort_by_digest = sort_by_digest_8_8;
8051 opti_type = OPTI_TYPE_ZERO_BYTE
8052 | OPTI_TYPE_PRECOMPUTE_INIT
8053 | OPTI_TYPE_PRECOMPUTE_MERKLE
8054 | OPTI_TYPE_EARLY_SKIP
8055 | OPTI_TYPE_NOT_ITERATED
8056 | OPTI_TYPE_PREPENDED_SALT
8057 | OPTI_TYPE_USES_BITS_64
8058 | OPTI_TYPE_RAW_HASH;
8059 dgst_pos0 = 14;
8060 dgst_pos1 = 15;
8061 dgst_pos2 = 6;
8062 dgst_pos3 = 7;
8063 break;
8064
8065 case 1722: hash_type = HASH_TYPE_SHA512;
8066 salt_type = SALT_TYPE_EMBEDDED;
8067 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8068 opts_type = OPTS_TYPE_PT_GENERATE_BE
8069 | OPTS_TYPE_PT_ADD80
8070 | OPTS_TYPE_PT_ADDBITS15
8071 | OPTS_TYPE_ST_HEX;
8072 kern_type = KERN_TYPE_SHA512_SLTPW;
8073 dgst_size = DGST_SIZE_8_8;
8074 parse_func = osx512_parse_hash;
8075 sort_by_digest = sort_by_digest_8_8;
8076 opti_type = OPTI_TYPE_ZERO_BYTE
8077 | OPTI_TYPE_PRECOMPUTE_INIT
8078 | OPTI_TYPE_PRECOMPUTE_MERKLE
8079 | OPTI_TYPE_EARLY_SKIP
8080 | OPTI_TYPE_NOT_ITERATED
8081 | OPTI_TYPE_PREPENDED_SALT
8082 | OPTI_TYPE_USES_BITS_64
8083 | OPTI_TYPE_RAW_HASH;
8084 dgst_pos0 = 14;
8085 dgst_pos1 = 15;
8086 dgst_pos2 = 6;
8087 dgst_pos3 = 7;
8088 break;
8089
8090 case 1730: hash_type = HASH_TYPE_SHA512;
8091 salt_type = SALT_TYPE_INTERN;
8092 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8093 opts_type = OPTS_TYPE_PT_GENERATE_BE
8094 | OPTS_TYPE_PT_UNICODE
8095 | OPTS_TYPE_ST_ADD80
8096 | OPTS_TYPE_ST_ADDBITS15;
8097 kern_type = KERN_TYPE_SHA512_PWSLTU;
8098 dgst_size = DGST_SIZE_8_8;
8099 parse_func = sha512s_parse_hash;
8100 sort_by_digest = sort_by_digest_8_8;
8101 opti_type = OPTI_TYPE_ZERO_BYTE
8102 | OPTI_TYPE_PRECOMPUTE_INIT
8103 | OPTI_TYPE_PRECOMPUTE_MERKLE
8104 | OPTI_TYPE_EARLY_SKIP
8105 | OPTI_TYPE_NOT_ITERATED
8106 | OPTI_TYPE_APPENDED_SALT
8107 | OPTI_TYPE_USES_BITS_64
8108 | OPTI_TYPE_RAW_HASH;
8109 dgst_pos0 = 14;
8110 dgst_pos1 = 15;
8111 dgst_pos2 = 6;
8112 dgst_pos3 = 7;
8113 break;
8114
8115 case 1731: hash_type = HASH_TYPE_SHA512;
8116 salt_type = SALT_TYPE_EMBEDDED;
8117 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8118 opts_type = OPTS_TYPE_PT_GENERATE_BE
8119 | OPTS_TYPE_PT_UNICODE
8120 | OPTS_TYPE_ST_ADD80
8121 | OPTS_TYPE_ST_ADDBITS15
8122 | OPTS_TYPE_ST_HEX;
8123 kern_type = KERN_TYPE_SHA512_PWSLTU;
8124 dgst_size = DGST_SIZE_8_8;
8125 parse_func = mssql2012_parse_hash;
8126 sort_by_digest = sort_by_digest_8_8;
8127 opti_type = OPTI_TYPE_ZERO_BYTE
8128 | OPTI_TYPE_PRECOMPUTE_INIT
8129 | OPTI_TYPE_PRECOMPUTE_MERKLE
8130 | OPTI_TYPE_EARLY_SKIP
8131 | OPTI_TYPE_NOT_ITERATED
8132 | OPTI_TYPE_APPENDED_SALT
8133 | OPTI_TYPE_USES_BITS_64
8134 | OPTI_TYPE_RAW_HASH;
8135 dgst_pos0 = 14;
8136 dgst_pos1 = 15;
8137 dgst_pos2 = 6;
8138 dgst_pos3 = 7;
8139 break;
8140
8141 case 1740: hash_type = HASH_TYPE_SHA512;
8142 salt_type = SALT_TYPE_INTERN;
8143 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8144 opts_type = OPTS_TYPE_PT_GENERATE_BE
8145 | OPTS_TYPE_PT_ADD80
8146 | OPTS_TYPE_PT_ADDBITS15
8147 | OPTS_TYPE_PT_UNICODE;
8148 kern_type = KERN_TYPE_SHA512_SLTPWU;
8149 dgst_size = DGST_SIZE_8_8;
8150 parse_func = sha512s_parse_hash;
8151 sort_by_digest = sort_by_digest_8_8;
8152 opti_type = OPTI_TYPE_ZERO_BYTE
8153 | OPTI_TYPE_PRECOMPUTE_INIT
8154 | OPTI_TYPE_PRECOMPUTE_MERKLE
8155 | OPTI_TYPE_EARLY_SKIP
8156 | OPTI_TYPE_NOT_ITERATED
8157 | OPTI_TYPE_PREPENDED_SALT
8158 | OPTI_TYPE_USES_BITS_64
8159 | OPTI_TYPE_RAW_HASH;
8160 dgst_pos0 = 14;
8161 dgst_pos1 = 15;
8162 dgst_pos2 = 6;
8163 dgst_pos3 = 7;
8164 break;
8165
8166 case 1750: hash_type = HASH_TYPE_SHA512;
8167 salt_type = SALT_TYPE_INTERN;
8168 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8169 opts_type = OPTS_TYPE_PT_GENERATE_BE
8170 | OPTS_TYPE_ST_ADD80;
8171 kern_type = KERN_TYPE_HMACSHA512_PW;
8172 dgst_size = DGST_SIZE_8_8;
8173 parse_func = hmacsha512_parse_hash;
8174 sort_by_digest = sort_by_digest_8_8;
8175 opti_type = OPTI_TYPE_ZERO_BYTE
8176 | OPTI_TYPE_USES_BITS_64
8177 | OPTI_TYPE_NOT_ITERATED;
8178 dgst_pos0 = 14;
8179 dgst_pos1 = 15;
8180 dgst_pos2 = 6;
8181 dgst_pos3 = 7;
8182 break;
8183
8184 case 1760: hash_type = HASH_TYPE_SHA512;
8185 salt_type = SALT_TYPE_INTERN;
8186 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8187 opts_type = OPTS_TYPE_PT_GENERATE_BE
8188 | OPTS_TYPE_PT_ADD80
8189 | OPTS_TYPE_PT_ADDBITS15;
8190 kern_type = KERN_TYPE_HMACSHA512_SLT;
8191 dgst_size = DGST_SIZE_8_8;
8192 parse_func = hmacsha512_parse_hash;
8193 sort_by_digest = sort_by_digest_8_8;
8194 opti_type = OPTI_TYPE_ZERO_BYTE
8195 | OPTI_TYPE_USES_BITS_64
8196 | OPTI_TYPE_NOT_ITERATED;
8197 dgst_pos0 = 14;
8198 dgst_pos1 = 15;
8199 dgst_pos2 = 6;
8200 dgst_pos3 = 7;
8201 break;
8202
8203 case 1800: hash_type = HASH_TYPE_SHA512;
8204 salt_type = SALT_TYPE_EMBEDDED;
8205 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8206 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8207 kern_type = KERN_TYPE_SHA512CRYPT;
8208 dgst_size = DGST_SIZE_8_8;
8209 parse_func = sha512crypt_parse_hash;
8210 sort_by_digest = sort_by_digest_8_8;
8211 opti_type = OPTI_TYPE_ZERO_BYTE
8212 | OPTI_TYPE_USES_BITS_64;
8213 dgst_pos0 = 0;
8214 dgst_pos1 = 1;
8215 dgst_pos2 = 2;
8216 dgst_pos3 = 3;
8217 break;
8218
8219 case 2100: hash_type = HASH_TYPE_DCC2;
8220 salt_type = SALT_TYPE_EMBEDDED;
8221 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8222 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8223 | OPTS_TYPE_ST_LOWER
8224 | OPTS_TYPE_ST_UNICODE;
8225 kern_type = KERN_TYPE_DCC2;
8226 dgst_size = DGST_SIZE_4_4;
8227 parse_func = dcc2_parse_hash;
8228 sort_by_digest = sort_by_digest_4_4;
8229 opti_type = OPTI_TYPE_ZERO_BYTE;
8230 dgst_pos0 = 0;
8231 dgst_pos1 = 1;
8232 dgst_pos2 = 2;
8233 dgst_pos3 = 3;
8234 break;
8235
8236 case 2400: hash_type = HASH_TYPE_MD5;
8237 salt_type = SALT_TYPE_NONE;
8238 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8239 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8240 kern_type = KERN_TYPE_MD5PIX;
8241 dgst_size = DGST_SIZE_4_4;
8242 parse_func = md5pix_parse_hash;
8243 sort_by_digest = sort_by_digest_4_4;
8244 opti_type = OPTI_TYPE_ZERO_BYTE
8245 | OPTI_TYPE_PRECOMPUTE_INIT
8246 | OPTI_TYPE_PRECOMPUTE_MERKLE
8247 | OPTI_TYPE_EARLY_SKIP
8248 | OPTI_TYPE_NOT_ITERATED
8249 | OPTI_TYPE_NOT_SALTED;
8250 dgst_pos0 = 0;
8251 dgst_pos1 = 3;
8252 dgst_pos2 = 2;
8253 dgst_pos3 = 1;
8254 break;
8255
8256 case 2410: hash_type = HASH_TYPE_MD5;
8257 salt_type = SALT_TYPE_INTERN;
8258 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8259 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8260 kern_type = KERN_TYPE_MD5ASA;
8261 dgst_size = DGST_SIZE_4_4;
8262 parse_func = md5asa_parse_hash;
8263 sort_by_digest = sort_by_digest_4_4;
8264 opti_type = OPTI_TYPE_ZERO_BYTE
8265 | OPTI_TYPE_PRECOMPUTE_INIT
8266 | OPTI_TYPE_PRECOMPUTE_MERKLE
8267 | OPTI_TYPE_EARLY_SKIP
8268 | OPTI_TYPE_NOT_ITERATED;
8269 dgst_pos0 = 0;
8270 dgst_pos1 = 3;
8271 dgst_pos2 = 2;
8272 dgst_pos3 = 1;
8273 break;
8274
8275 case 2500: hash_type = HASH_TYPE_WPA;
8276 salt_type = SALT_TYPE_EMBEDDED;
8277 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8278 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8279 kern_type = KERN_TYPE_WPA;
8280 dgst_size = DGST_SIZE_4_4;
8281 parse_func = wpa_parse_hash;
8282 sort_by_digest = sort_by_digest_4_4;
8283 opti_type = OPTI_TYPE_ZERO_BYTE;
8284 dgst_pos0 = 0;
8285 dgst_pos1 = 1;
8286 dgst_pos2 = 2;
8287 dgst_pos3 = 3;
8288 break;
8289
8290 case 2600: hash_type = HASH_TYPE_MD5;
8291 salt_type = SALT_TYPE_VIRTUAL;
8292 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8293 opts_type = OPTS_TYPE_PT_GENERATE_LE
8294 | OPTS_TYPE_PT_ADD80
8295 | OPTS_TYPE_PT_ADDBITS14
8296 | OPTS_TYPE_ST_ADD80;
8297 kern_type = KERN_TYPE_MD55_PWSLT1;
8298 dgst_size = DGST_SIZE_4_4;
8299 parse_func = md5md5_parse_hash;
8300 sort_by_digest = sort_by_digest_4_4;
8301 opti_type = OPTI_TYPE_ZERO_BYTE
8302 | OPTI_TYPE_PRECOMPUTE_INIT
8303 | OPTI_TYPE_PRECOMPUTE_MERKLE
8304 | OPTI_TYPE_EARLY_SKIP;
8305 dgst_pos0 = 0;
8306 dgst_pos1 = 3;
8307 dgst_pos2 = 2;
8308 dgst_pos3 = 1;
8309 break;
8310
8311 case 2611: hash_type = HASH_TYPE_MD5;
8312 salt_type = SALT_TYPE_INTERN;
8313 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8314 opts_type = OPTS_TYPE_PT_GENERATE_LE
8315 | OPTS_TYPE_PT_ADD80
8316 | OPTS_TYPE_PT_ADDBITS14
8317 | OPTS_TYPE_ST_ADD80;
8318 kern_type = KERN_TYPE_MD55_PWSLT1;
8319 dgst_size = DGST_SIZE_4_4;
8320 parse_func = vb3_parse_hash;
8321 sort_by_digest = sort_by_digest_4_4;
8322 opti_type = OPTI_TYPE_ZERO_BYTE
8323 | OPTI_TYPE_PRECOMPUTE_INIT
8324 | OPTI_TYPE_PRECOMPUTE_MERKLE
8325 | OPTI_TYPE_EARLY_SKIP;
8326 dgst_pos0 = 0;
8327 dgst_pos1 = 3;
8328 dgst_pos2 = 2;
8329 dgst_pos3 = 1;
8330 break;
8331
8332 case 2612: hash_type = HASH_TYPE_MD5;
8333 salt_type = SALT_TYPE_EMBEDDED;
8334 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8335 opts_type = OPTS_TYPE_PT_GENERATE_LE
8336 | OPTS_TYPE_PT_ADD80
8337 | OPTS_TYPE_PT_ADDBITS14
8338 | OPTS_TYPE_ST_ADD80
8339 | OPTS_TYPE_ST_HEX;
8340 kern_type = KERN_TYPE_MD55_PWSLT1;
8341 dgst_size = DGST_SIZE_4_4;
8342 parse_func = phps_parse_hash;
8343 sort_by_digest = sort_by_digest_4_4;
8344 opti_type = OPTI_TYPE_ZERO_BYTE
8345 | OPTI_TYPE_PRECOMPUTE_INIT
8346 | OPTI_TYPE_PRECOMPUTE_MERKLE
8347 | OPTI_TYPE_EARLY_SKIP;
8348 dgst_pos0 = 0;
8349 dgst_pos1 = 3;
8350 dgst_pos2 = 2;
8351 dgst_pos3 = 1;
8352 break;
8353
8354 case 2711: hash_type = HASH_TYPE_MD5;
8355 salt_type = SALT_TYPE_INTERN;
8356 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8357 opts_type = OPTS_TYPE_PT_GENERATE_LE
8358 | OPTS_TYPE_PT_ADD80
8359 | OPTS_TYPE_PT_ADDBITS14
8360 | OPTS_TYPE_ST_ADD80;
8361 kern_type = KERN_TYPE_MD55_PWSLT2;
8362 dgst_size = DGST_SIZE_4_4;
8363 parse_func = vb30_parse_hash;
8364 sort_by_digest = sort_by_digest_4_4;
8365 opti_type = OPTI_TYPE_ZERO_BYTE
8366 | OPTI_TYPE_PRECOMPUTE_INIT
8367 | OPTI_TYPE_EARLY_SKIP;
8368 dgst_pos0 = 0;
8369 dgst_pos1 = 3;
8370 dgst_pos2 = 2;
8371 dgst_pos3 = 1;
8372 break;
8373
8374 case 2811: hash_type = HASH_TYPE_MD5;
8375 salt_type = SALT_TYPE_INTERN;
8376 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8377 opts_type = OPTS_TYPE_PT_GENERATE_LE
8378 | OPTS_TYPE_PT_ADD80
8379 | OPTS_TYPE_PT_ADDBITS14;
8380 kern_type = KERN_TYPE_MD55_SLTPW;
8381 dgst_size = DGST_SIZE_4_4;
8382 parse_func = ipb2_parse_hash;
8383 sort_by_digest = sort_by_digest_4_4;
8384 opti_type = OPTI_TYPE_ZERO_BYTE
8385 | OPTI_TYPE_PRECOMPUTE_INIT
8386 | OPTI_TYPE_EARLY_SKIP;
8387 dgst_pos0 = 0;
8388 dgst_pos1 = 3;
8389 dgst_pos2 = 2;
8390 dgst_pos3 = 1;
8391 break;
8392
8393 case 3000: hash_type = HASH_TYPE_LM;
8394 salt_type = SALT_TYPE_NONE;
8395 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8396 opts_type = OPTS_TYPE_PT_GENERATE_LE
8397 | OPTS_TYPE_PT_UPPER
8398 | OPTS_TYPE_PT_BITSLICE;
8399 kern_type = KERN_TYPE_LM;
8400 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8401 parse_func = lm_parse_hash;
8402 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8403 opti_type = OPTI_TYPE_ZERO_BYTE
8404 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8405 dgst_pos0 = 0;
8406 dgst_pos1 = 1;
8407 dgst_pos2 = 2;
8408 dgst_pos3 = 3;
8409 break;
8410
8411 case 3100: hash_type = HASH_TYPE_ORACLEH;
8412 salt_type = SALT_TYPE_INTERN;
8413 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8414 opts_type = OPTS_TYPE_PT_GENERATE_LE
8415 | OPTS_TYPE_PT_UPPER
8416 | OPTS_TYPE_ST_UPPER;
8417 kern_type = KERN_TYPE_ORACLEH;
8418 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8419 parse_func = oracleh_parse_hash;
8420 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8421 opti_type = OPTI_TYPE_ZERO_BYTE;
8422 dgst_pos0 = 0;
8423 dgst_pos1 = 1;
8424 dgst_pos2 = 2;
8425 dgst_pos3 = 3;
8426 break;
8427
8428 case 3200: hash_type = HASH_TYPE_BCRYPT;
8429 salt_type = SALT_TYPE_EMBEDDED;
8430 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8431 opts_type = OPTS_TYPE_PT_GENERATE_LE
8432 | OPTS_TYPE_ST_GENERATE_LE;
8433 kern_type = KERN_TYPE_BCRYPT;
8434 dgst_size = DGST_SIZE_4_6;
8435 parse_func = bcrypt_parse_hash;
8436 sort_by_digest = sort_by_digest_4_6;
8437 opti_type = OPTI_TYPE_ZERO_BYTE;
8438 dgst_pos0 = 0;
8439 dgst_pos1 = 1;
8440 dgst_pos2 = 2;
8441 dgst_pos3 = 3;
8442 break;
8443
8444 case 3710: hash_type = HASH_TYPE_MD5;
8445 salt_type = SALT_TYPE_INTERN;
8446 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8447 opts_type = OPTS_TYPE_PT_GENERATE_LE
8448 | OPTS_TYPE_PT_ADD80
8449 | OPTS_TYPE_PT_ADDBITS14;
8450 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8451 dgst_size = DGST_SIZE_4_4;
8452 parse_func = md5s_parse_hash;
8453 sort_by_digest = sort_by_digest_4_4;
8454 opti_type = OPTI_TYPE_ZERO_BYTE
8455 | OPTI_TYPE_PRECOMPUTE_INIT
8456 | OPTI_TYPE_PRECOMPUTE_MERKLE
8457 | OPTI_TYPE_EARLY_SKIP;
8458 dgst_pos0 = 0;
8459 dgst_pos1 = 3;
8460 dgst_pos2 = 2;
8461 dgst_pos3 = 1;
8462 break;
8463
8464 case 3711: hash_type = HASH_TYPE_MD5;
8465 salt_type = SALT_TYPE_EMBEDDED;
8466 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8467 opts_type = OPTS_TYPE_PT_GENERATE_LE
8468 | OPTS_TYPE_PT_ADD80
8469 | OPTS_TYPE_PT_ADDBITS14;
8470 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8471 dgst_size = DGST_SIZE_4_4;
8472 parse_func = mediawiki_b_parse_hash;
8473 sort_by_digest = sort_by_digest_4_4;
8474 opti_type = OPTI_TYPE_ZERO_BYTE
8475 | OPTI_TYPE_PRECOMPUTE_INIT
8476 | OPTI_TYPE_PRECOMPUTE_MERKLE
8477 | OPTI_TYPE_EARLY_SKIP;
8478 dgst_pos0 = 0;
8479 dgst_pos1 = 3;
8480 dgst_pos2 = 2;
8481 dgst_pos3 = 1;
8482 break;
8483
8484 case 3800: hash_type = HASH_TYPE_MD5;
8485 salt_type = SALT_TYPE_INTERN;
8486 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8487 opts_type = OPTS_TYPE_PT_GENERATE_LE
8488 | OPTS_TYPE_ST_ADDBITS14;
8489 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8490 dgst_size = DGST_SIZE_4_4;
8491 parse_func = md5s_parse_hash;
8492 sort_by_digest = sort_by_digest_4_4;
8493 opti_type = OPTI_TYPE_ZERO_BYTE
8494 | OPTI_TYPE_PRECOMPUTE_INIT
8495 | OPTI_TYPE_PRECOMPUTE_MERKLE
8496 | OPTI_TYPE_EARLY_SKIP
8497 | OPTI_TYPE_NOT_ITERATED
8498 | OPTI_TYPE_RAW_HASH;
8499 dgst_pos0 = 0;
8500 dgst_pos1 = 3;
8501 dgst_pos2 = 2;
8502 dgst_pos3 = 1;
8503 break;
8504
8505 case 4300: hash_type = HASH_TYPE_MD5;
8506 salt_type = SALT_TYPE_VIRTUAL;
8507 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8508 opts_type = OPTS_TYPE_PT_GENERATE_LE
8509 | OPTS_TYPE_PT_ADD80
8510 | OPTS_TYPE_PT_ADDBITS14
8511 | OPTS_TYPE_ST_ADD80;
8512 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8513 dgst_size = DGST_SIZE_4_4;
8514 parse_func = md5md5_parse_hash;
8515 sort_by_digest = sort_by_digest_4_4;
8516 opti_type = OPTI_TYPE_ZERO_BYTE
8517 | OPTI_TYPE_PRECOMPUTE_INIT
8518 | OPTI_TYPE_PRECOMPUTE_MERKLE
8519 | OPTI_TYPE_EARLY_SKIP;
8520 dgst_pos0 = 0;
8521 dgst_pos1 = 3;
8522 dgst_pos2 = 2;
8523 dgst_pos3 = 1;
8524 break;
8525
8526
8527 case 4400: hash_type = HASH_TYPE_MD5;
8528 salt_type = SALT_TYPE_NONE;
8529 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8530 opts_type = OPTS_TYPE_PT_GENERATE_BE
8531 | OPTS_TYPE_PT_ADD80
8532 | OPTS_TYPE_PT_ADDBITS15;
8533 kern_type = KERN_TYPE_MD5_SHA1;
8534 dgst_size = DGST_SIZE_4_4;
8535 parse_func = md5_parse_hash;
8536 sort_by_digest = sort_by_digest_4_4;
8537 opti_type = OPTI_TYPE_ZERO_BYTE
8538 | OPTI_TYPE_PRECOMPUTE_INIT
8539 | OPTI_TYPE_PRECOMPUTE_MERKLE
8540 | OPTI_TYPE_EARLY_SKIP
8541 | OPTI_TYPE_NOT_ITERATED
8542 | OPTI_TYPE_NOT_SALTED
8543 | OPTI_TYPE_RAW_HASH;
8544 dgst_pos0 = 0;
8545 dgst_pos1 = 3;
8546 dgst_pos2 = 2;
8547 dgst_pos3 = 1;
8548 break;
8549
8550 case 4500: hash_type = HASH_TYPE_SHA1;
8551 salt_type = SALT_TYPE_NONE;
8552 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8553 opts_type = OPTS_TYPE_PT_GENERATE_BE
8554 | OPTS_TYPE_PT_ADD80
8555 | OPTS_TYPE_PT_ADDBITS15;
8556 kern_type = KERN_TYPE_SHA11;
8557 dgst_size = DGST_SIZE_4_5;
8558 parse_func = sha1_parse_hash;
8559 sort_by_digest = sort_by_digest_4_5;
8560 opti_type = OPTI_TYPE_ZERO_BYTE
8561 | OPTI_TYPE_PRECOMPUTE_INIT
8562 | OPTI_TYPE_PRECOMPUTE_MERKLE
8563 | OPTI_TYPE_EARLY_SKIP
8564 | OPTI_TYPE_NOT_SALTED;
8565 dgst_pos0 = 3;
8566 dgst_pos1 = 4;
8567 dgst_pos2 = 2;
8568 dgst_pos3 = 1;
8569 break;
8570
8571 case 4700: hash_type = HASH_TYPE_SHA1;
8572 salt_type = SALT_TYPE_NONE;
8573 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8574 opts_type = OPTS_TYPE_PT_GENERATE_LE
8575 | OPTS_TYPE_PT_ADD80
8576 | OPTS_TYPE_PT_ADDBITS14;
8577 kern_type = KERN_TYPE_SHA1_MD5;
8578 dgst_size = DGST_SIZE_4_5;
8579 parse_func = sha1_parse_hash;
8580 sort_by_digest = sort_by_digest_4_5;
8581 opti_type = OPTI_TYPE_ZERO_BYTE
8582 | OPTI_TYPE_PRECOMPUTE_INIT
8583 | OPTI_TYPE_PRECOMPUTE_MERKLE
8584 | OPTI_TYPE_EARLY_SKIP
8585 | OPTI_TYPE_NOT_ITERATED
8586 | OPTI_TYPE_NOT_SALTED
8587 | OPTI_TYPE_RAW_HASH;
8588 dgst_pos0 = 3;
8589 dgst_pos1 = 4;
8590 dgst_pos2 = 2;
8591 dgst_pos3 = 1;
8592 break;
8593
8594 case 4800: hash_type = HASH_TYPE_MD5;
8595 salt_type = SALT_TYPE_EMBEDDED;
8596 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8597 opts_type = OPTS_TYPE_PT_GENERATE_LE
8598 | OPTS_TYPE_PT_ADDBITS14;
8599 kern_type = KERN_TYPE_MD5_CHAP;
8600 dgst_size = DGST_SIZE_4_4;
8601 parse_func = chap_parse_hash;
8602 sort_by_digest = sort_by_digest_4_4;
8603 opti_type = OPTI_TYPE_ZERO_BYTE
8604 | OPTI_TYPE_PRECOMPUTE_INIT
8605 | OPTI_TYPE_PRECOMPUTE_MERKLE
8606 | OPTI_TYPE_MEET_IN_MIDDLE
8607 | OPTI_TYPE_EARLY_SKIP
8608 | OPTI_TYPE_NOT_ITERATED
8609 | OPTI_TYPE_RAW_HASH;
8610 dgst_pos0 = 0;
8611 dgst_pos1 = 3;
8612 dgst_pos2 = 2;
8613 dgst_pos3 = 1;
8614 break;
8615
8616 case 4900: hash_type = HASH_TYPE_SHA1;
8617 salt_type = SALT_TYPE_INTERN;
8618 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8619 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8620 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8621 dgst_size = DGST_SIZE_4_5;
8622 parse_func = sha1s_parse_hash;
8623 sort_by_digest = sort_by_digest_4_5;
8624 opti_type = OPTI_TYPE_ZERO_BYTE
8625 | OPTI_TYPE_PRECOMPUTE_INIT
8626 | OPTI_TYPE_PRECOMPUTE_MERKLE
8627 | OPTI_TYPE_EARLY_SKIP;
8628 dgst_pos0 = 3;
8629 dgst_pos1 = 4;
8630 dgst_pos2 = 2;
8631 dgst_pos3 = 1;
8632 break;
8633
8634 case 5000: hash_type = HASH_TYPE_KECCAK;
8635 salt_type = SALT_TYPE_EMBEDDED;
8636 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8637 opts_type = OPTS_TYPE_PT_GENERATE_LE
8638 | OPTS_TYPE_PT_ADD01;
8639 kern_type = KERN_TYPE_KECCAK;
8640 dgst_size = DGST_SIZE_8_25;
8641 parse_func = keccak_parse_hash;
8642 sort_by_digest = sort_by_digest_8_25;
8643 opti_type = OPTI_TYPE_ZERO_BYTE
8644 | OPTI_TYPE_USES_BITS_64
8645 | OPTI_TYPE_RAW_HASH;
8646 dgst_pos0 = 2;
8647 dgst_pos1 = 3;
8648 dgst_pos2 = 4;
8649 dgst_pos3 = 5;
8650 break;
8651
8652 case 5100: hash_type = HASH_TYPE_MD5H;
8653 salt_type = SALT_TYPE_NONE;
8654 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8655 opts_type = OPTS_TYPE_PT_GENERATE_LE
8656 | OPTS_TYPE_PT_ADD80
8657 | OPTS_TYPE_PT_ADDBITS14;
8658 kern_type = KERN_TYPE_MD5H;
8659 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8660 parse_func = md5half_parse_hash;
8661 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8662 opti_type = OPTI_TYPE_ZERO_BYTE
8663 | OPTI_TYPE_RAW_HASH;
8664 dgst_pos0 = 0;
8665 dgst_pos1 = 1;
8666 dgst_pos2 = 2;
8667 dgst_pos3 = 3;
8668 break;
8669
8670 case 5200: hash_type = HASH_TYPE_SHA256;
8671 salt_type = SALT_TYPE_EMBEDDED;
8672 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8673 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8674 kern_type = KERN_TYPE_PSAFE3;
8675 dgst_size = DGST_SIZE_4_8;
8676 parse_func = psafe3_parse_hash;
8677 sort_by_digest = sort_by_digest_4_8;
8678 opti_type = OPTI_TYPE_ZERO_BYTE;
8679 dgst_pos0 = 0;
8680 dgst_pos1 = 1;
8681 dgst_pos2 = 2;
8682 dgst_pos3 = 3;
8683 break;
8684
8685 case 5300: hash_type = HASH_TYPE_MD5;
8686 salt_type = SALT_TYPE_EMBEDDED;
8687 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8688 opts_type = OPTS_TYPE_PT_GENERATE_LE
8689 | OPTS_TYPE_ST_ADD80;
8690 kern_type = KERN_TYPE_IKEPSK_MD5;
8691 dgst_size = DGST_SIZE_4_4;
8692 parse_func = ikepsk_md5_parse_hash;
8693 sort_by_digest = sort_by_digest_4_4;
8694 opti_type = OPTI_TYPE_ZERO_BYTE;
8695 dgst_pos0 = 0;
8696 dgst_pos1 = 3;
8697 dgst_pos2 = 2;
8698 dgst_pos3 = 1;
8699 break;
8700
8701 case 5400: hash_type = HASH_TYPE_SHA1;
8702 salt_type = SALT_TYPE_EMBEDDED;
8703 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8704 opts_type = OPTS_TYPE_PT_GENERATE_BE
8705 | OPTS_TYPE_ST_ADD80;
8706 kern_type = KERN_TYPE_IKEPSK_SHA1;
8707 dgst_size = DGST_SIZE_4_5;
8708 parse_func = ikepsk_sha1_parse_hash;
8709 sort_by_digest = sort_by_digest_4_5;
8710 opti_type = OPTI_TYPE_ZERO_BYTE;
8711 dgst_pos0 = 3;
8712 dgst_pos1 = 4;
8713 dgst_pos2 = 2;
8714 dgst_pos3 = 1;
8715 break;
8716
8717 case 5500: hash_type = HASH_TYPE_NETNTLM;
8718 salt_type = SALT_TYPE_EMBEDDED;
8719 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8720 opts_type = OPTS_TYPE_PT_GENERATE_LE
8721 | OPTS_TYPE_PT_ADD80
8722 | OPTS_TYPE_PT_ADDBITS14
8723 | OPTS_TYPE_PT_UNICODE
8724 | OPTS_TYPE_ST_HEX;
8725 kern_type = KERN_TYPE_NETNTLMv1;
8726 dgst_size = DGST_SIZE_4_4;
8727 parse_func = netntlmv1_parse_hash;
8728 sort_by_digest = sort_by_digest_4_4;
8729 opti_type = OPTI_TYPE_ZERO_BYTE
8730 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8731 dgst_pos0 = 0;
8732 dgst_pos1 = 1;
8733 dgst_pos2 = 2;
8734 dgst_pos3 = 3;
8735 break;
8736
8737 case 5600: hash_type = HASH_TYPE_MD5;
8738 salt_type = SALT_TYPE_EMBEDDED;
8739 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8740 opts_type = OPTS_TYPE_PT_GENERATE_LE
8741 | OPTS_TYPE_PT_ADD80
8742 | OPTS_TYPE_PT_ADDBITS14
8743 | OPTS_TYPE_PT_UNICODE;
8744 kern_type = KERN_TYPE_NETNTLMv2;
8745 dgst_size = DGST_SIZE_4_4;
8746 parse_func = netntlmv2_parse_hash;
8747 sort_by_digest = sort_by_digest_4_4;
8748 opti_type = OPTI_TYPE_ZERO_BYTE;
8749 dgst_pos0 = 0;
8750 dgst_pos1 = 3;
8751 dgst_pos2 = 2;
8752 dgst_pos3 = 1;
8753 break;
8754
8755 case 5700: hash_type = HASH_TYPE_SHA256;
8756 salt_type = SALT_TYPE_NONE;
8757 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8758 opts_type = OPTS_TYPE_PT_GENERATE_BE
8759 | OPTS_TYPE_PT_ADD80
8760 | OPTS_TYPE_PT_ADDBITS15;
8761 kern_type = KERN_TYPE_SHA256;
8762 dgst_size = DGST_SIZE_4_8;
8763 parse_func = cisco4_parse_hash;
8764 sort_by_digest = sort_by_digest_4_8;
8765 opti_type = OPTI_TYPE_ZERO_BYTE
8766 | OPTI_TYPE_PRECOMPUTE_INIT
8767 | OPTI_TYPE_PRECOMPUTE_MERKLE
8768 | OPTI_TYPE_EARLY_SKIP
8769 | OPTI_TYPE_NOT_ITERATED
8770 | OPTI_TYPE_NOT_SALTED
8771 | OPTI_TYPE_RAW_HASH;
8772 dgst_pos0 = 3;
8773 dgst_pos1 = 7;
8774 dgst_pos2 = 2;
8775 dgst_pos3 = 6;
8776 break;
8777
8778 case 5800: hash_type = HASH_TYPE_SHA1;
8779 salt_type = SALT_TYPE_INTERN;
8780 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8781 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8782 | OPTS_TYPE_ST_ADD80;
8783 kern_type = KERN_TYPE_ANDROIDPIN;
8784 dgst_size = DGST_SIZE_4_5;
8785 parse_func = androidpin_parse_hash;
8786 sort_by_digest = sort_by_digest_4_5;
8787 opti_type = OPTI_TYPE_ZERO_BYTE;
8788 dgst_pos0 = 0;
8789 dgst_pos1 = 1;
8790 dgst_pos2 = 2;
8791 dgst_pos3 = 3;
8792 break;
8793
8794 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8795 salt_type = SALT_TYPE_NONE;
8796 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8797 opts_type = OPTS_TYPE_PT_GENERATE_LE
8798 | OPTS_TYPE_PT_ADD80;
8799 kern_type = KERN_TYPE_RIPEMD160;
8800 dgst_size = DGST_SIZE_4_5;
8801 parse_func = ripemd160_parse_hash;
8802 sort_by_digest = sort_by_digest_4_5;
8803 opti_type = OPTI_TYPE_ZERO_BYTE;
8804 dgst_pos0 = 0;
8805 dgst_pos1 = 1;
8806 dgst_pos2 = 2;
8807 dgst_pos3 = 3;
8808 break;
8809
8810 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8811 salt_type = SALT_TYPE_NONE;
8812 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8813 opts_type = OPTS_TYPE_PT_GENERATE_BE
8814 | OPTS_TYPE_PT_ADD80;
8815 kern_type = KERN_TYPE_WHIRLPOOL;
8816 dgst_size = DGST_SIZE_4_16;
8817 parse_func = whirlpool_parse_hash;
8818 sort_by_digest = sort_by_digest_4_16;
8819 opti_type = OPTI_TYPE_ZERO_BYTE;
8820 dgst_pos0 = 0;
8821 dgst_pos1 = 1;
8822 dgst_pos2 = 2;
8823 dgst_pos3 = 3;
8824 break;
8825
8826 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8827 salt_type = SALT_TYPE_EMBEDDED;
8828 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8829 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8830 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8831 dgst_size = DGST_SIZE_4_5;
8832 parse_func = truecrypt_parse_hash_2k;
8833 sort_by_digest = sort_by_digest_4_5;
8834 opti_type = OPTI_TYPE_ZERO_BYTE;
8835 dgst_pos0 = 0;
8836 dgst_pos1 = 1;
8837 dgst_pos2 = 2;
8838 dgst_pos3 = 3;
8839 break;
8840
8841 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8842 salt_type = SALT_TYPE_EMBEDDED;
8843 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8844 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8845 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8846 dgst_size = DGST_SIZE_4_5;
8847 parse_func = truecrypt_parse_hash_2k;
8848 sort_by_digest = sort_by_digest_4_5;
8849 opti_type = OPTI_TYPE_ZERO_BYTE;
8850 dgst_pos0 = 0;
8851 dgst_pos1 = 1;
8852 dgst_pos2 = 2;
8853 dgst_pos3 = 3;
8854 break;
8855
8856 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8857 salt_type = SALT_TYPE_EMBEDDED;
8858 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8859 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8860 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8861 dgst_size = DGST_SIZE_4_5;
8862 parse_func = truecrypt_parse_hash_2k;
8863 sort_by_digest = sort_by_digest_4_5;
8864 opti_type = OPTI_TYPE_ZERO_BYTE;
8865 dgst_pos0 = 0;
8866 dgst_pos1 = 1;
8867 dgst_pos2 = 2;
8868 dgst_pos3 = 3;
8869 break;
8870
8871 case 6221: hash_type = HASH_TYPE_SHA512;
8872 salt_type = SALT_TYPE_EMBEDDED;
8873 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8874 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8875 kern_type = KERN_TYPE_TCSHA512_XTS512;
8876 dgst_size = DGST_SIZE_8_8;
8877 parse_func = truecrypt_parse_hash_1k;
8878 sort_by_digest = sort_by_digest_8_8;
8879 opti_type = OPTI_TYPE_ZERO_BYTE
8880 | OPTI_TYPE_USES_BITS_64;
8881 dgst_pos0 = 0;
8882 dgst_pos1 = 1;
8883 dgst_pos2 = 2;
8884 dgst_pos3 = 3;
8885 break;
8886
8887 case 6222: hash_type = HASH_TYPE_SHA512;
8888 salt_type = SALT_TYPE_EMBEDDED;
8889 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8890 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8891 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8892 dgst_size = DGST_SIZE_8_8;
8893 parse_func = truecrypt_parse_hash_1k;
8894 sort_by_digest = sort_by_digest_8_8;
8895 opti_type = OPTI_TYPE_ZERO_BYTE
8896 | OPTI_TYPE_USES_BITS_64;
8897 dgst_pos0 = 0;
8898 dgst_pos1 = 1;
8899 dgst_pos2 = 2;
8900 dgst_pos3 = 3;
8901 break;
8902
8903 case 6223: hash_type = HASH_TYPE_SHA512;
8904 salt_type = SALT_TYPE_EMBEDDED;
8905 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8906 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8907 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8908 dgst_size = DGST_SIZE_8_8;
8909 parse_func = truecrypt_parse_hash_1k;
8910 sort_by_digest = sort_by_digest_8_8;
8911 opti_type = OPTI_TYPE_ZERO_BYTE
8912 | OPTI_TYPE_USES_BITS_64;
8913 dgst_pos0 = 0;
8914 dgst_pos1 = 1;
8915 dgst_pos2 = 2;
8916 dgst_pos3 = 3;
8917 break;
8918
8919 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8920 salt_type = SALT_TYPE_EMBEDDED;
8921 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8922 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8923 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8924 dgst_size = DGST_SIZE_4_8;
8925 parse_func = truecrypt_parse_hash_1k;
8926 sort_by_digest = sort_by_digest_4_8;
8927 opti_type = OPTI_TYPE_ZERO_BYTE;
8928 dgst_pos0 = 0;
8929 dgst_pos1 = 1;
8930 dgst_pos2 = 2;
8931 dgst_pos3 = 3;
8932 break;
8933
8934 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8935 salt_type = SALT_TYPE_EMBEDDED;
8936 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8937 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8938 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8939 dgst_size = DGST_SIZE_4_8;
8940 parse_func = truecrypt_parse_hash_1k;
8941 sort_by_digest = sort_by_digest_4_8;
8942 opti_type = OPTI_TYPE_ZERO_BYTE;
8943 dgst_pos0 = 0;
8944 dgst_pos1 = 1;
8945 dgst_pos2 = 2;
8946 dgst_pos3 = 3;
8947 break;
8948
8949 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8950 salt_type = SALT_TYPE_EMBEDDED;
8951 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8952 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8953 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8954 dgst_size = DGST_SIZE_4_8;
8955 parse_func = truecrypt_parse_hash_1k;
8956 sort_by_digest = sort_by_digest_4_8;
8957 opti_type = OPTI_TYPE_ZERO_BYTE;
8958 dgst_pos0 = 0;
8959 dgst_pos1 = 1;
8960 dgst_pos2 = 2;
8961 dgst_pos3 = 3;
8962 break;
8963
8964 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8965 salt_type = SALT_TYPE_EMBEDDED;
8966 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8967 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8968 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8969 dgst_size = DGST_SIZE_4_5;
8970 parse_func = truecrypt_parse_hash_1k;
8971 sort_by_digest = sort_by_digest_4_5;
8972 opti_type = OPTI_TYPE_ZERO_BYTE;
8973 dgst_pos0 = 0;
8974 dgst_pos1 = 1;
8975 dgst_pos2 = 2;
8976 dgst_pos3 = 3;
8977 break;
8978
8979 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8980 salt_type = SALT_TYPE_EMBEDDED;
8981 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8982 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8983 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8984 dgst_size = DGST_SIZE_4_5;
8985 parse_func = truecrypt_parse_hash_1k;
8986 sort_by_digest = sort_by_digest_4_5;
8987 opti_type = OPTI_TYPE_ZERO_BYTE;
8988 dgst_pos0 = 0;
8989 dgst_pos1 = 1;
8990 dgst_pos2 = 2;
8991 dgst_pos3 = 3;
8992 break;
8993
8994 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8995 salt_type = SALT_TYPE_EMBEDDED;
8996 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8997 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8998 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8999 dgst_size = DGST_SIZE_4_5;
9000 parse_func = truecrypt_parse_hash_1k;
9001 sort_by_digest = sort_by_digest_4_5;
9002 opti_type = OPTI_TYPE_ZERO_BYTE;
9003 dgst_pos0 = 0;
9004 dgst_pos1 = 1;
9005 dgst_pos2 = 2;
9006 dgst_pos3 = 3;
9007 break;
9008
9009 case 6300: hash_type = HASH_TYPE_MD5;
9010 salt_type = SALT_TYPE_EMBEDDED;
9011 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9012 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9013 kern_type = KERN_TYPE_MD5AIX;
9014 dgst_size = DGST_SIZE_4_4;
9015 parse_func = md5aix_parse_hash;
9016 sort_by_digest = sort_by_digest_4_4;
9017 opti_type = OPTI_TYPE_ZERO_BYTE;
9018 dgst_pos0 = 0;
9019 dgst_pos1 = 1;
9020 dgst_pos2 = 2;
9021 dgst_pos3 = 3;
9022 break;
9023
9024 case 6400: hash_type = HASH_TYPE_SHA256;
9025 salt_type = SALT_TYPE_EMBEDDED;
9026 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9027 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9028 kern_type = KERN_TYPE_SHA256AIX;
9029 dgst_size = DGST_SIZE_4_8;
9030 parse_func = sha256aix_parse_hash;
9031 sort_by_digest = sort_by_digest_4_8;
9032 opti_type = OPTI_TYPE_ZERO_BYTE;
9033 dgst_pos0 = 0;
9034 dgst_pos1 = 1;
9035 dgst_pos2 = 2;
9036 dgst_pos3 = 3;
9037 break;
9038
9039 case 6500: hash_type = HASH_TYPE_SHA512;
9040 salt_type = SALT_TYPE_EMBEDDED;
9041 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9042 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9043 kern_type = KERN_TYPE_SHA512AIX;
9044 dgst_size = DGST_SIZE_8_8;
9045 parse_func = sha512aix_parse_hash;
9046 sort_by_digest = sort_by_digest_8_8;
9047 opti_type = OPTI_TYPE_ZERO_BYTE
9048 | OPTI_TYPE_USES_BITS_64;
9049 dgst_pos0 = 0;
9050 dgst_pos1 = 1;
9051 dgst_pos2 = 2;
9052 dgst_pos3 = 3;
9053 break;
9054
9055 case 6600: hash_type = HASH_TYPE_AES;
9056 salt_type = SALT_TYPE_EMBEDDED;
9057 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9058 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9059 kern_type = KERN_TYPE_AGILEKEY;
9060 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9061 parse_func = agilekey_parse_hash;
9062 sort_by_digest = sort_by_digest_4_5;
9063 opti_type = OPTI_TYPE_ZERO_BYTE;
9064 dgst_pos0 = 0;
9065 dgst_pos1 = 1;
9066 dgst_pos2 = 2;
9067 dgst_pos3 = 3;
9068 break;
9069
9070 case 6700: hash_type = HASH_TYPE_SHA1;
9071 salt_type = SALT_TYPE_EMBEDDED;
9072 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9073 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9074 kern_type = KERN_TYPE_SHA1AIX;
9075 dgst_size = DGST_SIZE_4_5;
9076 parse_func = sha1aix_parse_hash;
9077 sort_by_digest = sort_by_digest_4_5;
9078 opti_type = OPTI_TYPE_ZERO_BYTE;
9079 dgst_pos0 = 0;
9080 dgst_pos1 = 1;
9081 dgst_pos2 = 2;
9082 dgst_pos3 = 3;
9083 break;
9084
9085 case 6800: hash_type = HASH_TYPE_AES;
9086 salt_type = SALT_TYPE_EMBEDDED;
9087 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9088 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9089 kern_type = KERN_TYPE_LASTPASS;
9090 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9091 parse_func = lastpass_parse_hash;
9092 sort_by_digest = sort_by_digest_4_8;
9093 opti_type = OPTI_TYPE_ZERO_BYTE;
9094 dgst_pos0 = 0;
9095 dgst_pos1 = 1;
9096 dgst_pos2 = 2;
9097 dgst_pos3 = 3;
9098 break;
9099
9100 case 6900: hash_type = HASH_TYPE_GOST;
9101 salt_type = SALT_TYPE_NONE;
9102 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9103 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9104 kern_type = KERN_TYPE_GOST;
9105 dgst_size = DGST_SIZE_4_8;
9106 parse_func = gost_parse_hash;
9107 sort_by_digest = sort_by_digest_4_8;
9108 opti_type = OPTI_TYPE_ZERO_BYTE;
9109 dgst_pos0 = 0;
9110 dgst_pos1 = 1;
9111 dgst_pos2 = 2;
9112 dgst_pos3 = 3;
9113 break;
9114
9115 case 7100: hash_type = HASH_TYPE_SHA512;
9116 salt_type = SALT_TYPE_EMBEDDED;
9117 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9118 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9119 kern_type = KERN_TYPE_PBKDF2_SHA512;
9120 dgst_size = DGST_SIZE_8_16;
9121 parse_func = sha512osx_parse_hash;
9122 sort_by_digest = sort_by_digest_8_16;
9123 opti_type = OPTI_TYPE_ZERO_BYTE
9124 | OPTI_TYPE_USES_BITS_64;
9125 dgst_pos0 = 0;
9126 dgst_pos1 = 1;
9127 dgst_pos2 = 2;
9128 dgst_pos3 = 3;
9129 break;
9130
9131 case 7200: hash_type = HASH_TYPE_SHA512;
9132 salt_type = SALT_TYPE_EMBEDDED;
9133 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9134 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9135 kern_type = KERN_TYPE_PBKDF2_SHA512;
9136 dgst_size = DGST_SIZE_8_16;
9137 parse_func = sha512grub_parse_hash;
9138 sort_by_digest = sort_by_digest_8_16;
9139 opti_type = OPTI_TYPE_ZERO_BYTE
9140 | OPTI_TYPE_USES_BITS_64;
9141 dgst_pos0 = 0;
9142 dgst_pos1 = 1;
9143 dgst_pos2 = 2;
9144 dgst_pos3 = 3;
9145 break;
9146
9147 case 7300: hash_type = HASH_TYPE_SHA1;
9148 salt_type = SALT_TYPE_EMBEDDED;
9149 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9150 opts_type = OPTS_TYPE_PT_GENERATE_BE
9151 | OPTS_TYPE_ST_ADD80
9152 | OPTS_TYPE_ST_ADDBITS15;
9153 kern_type = KERN_TYPE_RAKP;
9154 dgst_size = DGST_SIZE_4_5;
9155 parse_func = rakp_parse_hash;
9156 sort_by_digest = sort_by_digest_4_5;
9157 opti_type = OPTI_TYPE_ZERO_BYTE
9158 | OPTI_TYPE_NOT_ITERATED;
9159 dgst_pos0 = 3;
9160 dgst_pos1 = 4;
9161 dgst_pos2 = 2;
9162 dgst_pos3 = 1;
9163 break;
9164
9165 case 7400: hash_type = HASH_TYPE_SHA256;
9166 salt_type = SALT_TYPE_EMBEDDED;
9167 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9168 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9169 kern_type = KERN_TYPE_SHA256CRYPT;
9170 dgst_size = DGST_SIZE_4_8;
9171 parse_func = sha256crypt_parse_hash;
9172 sort_by_digest = sort_by_digest_4_8;
9173 opti_type = OPTI_TYPE_ZERO_BYTE;
9174 dgst_pos0 = 0;
9175 dgst_pos1 = 1;
9176 dgst_pos2 = 2;
9177 dgst_pos3 = 3;
9178 break;
9179
9180 case 7500: hash_type = HASH_TYPE_KRB5PA;
9181 salt_type = SALT_TYPE_EMBEDDED;
9182 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9183 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9184 kern_type = KERN_TYPE_KRB5PA;
9185 dgst_size = DGST_SIZE_4_4;
9186 parse_func = krb5pa_parse_hash;
9187 sort_by_digest = sort_by_digest_4_4;
9188 opti_type = OPTI_TYPE_ZERO_BYTE
9189 | OPTI_TYPE_NOT_ITERATED;
9190 dgst_pos0 = 0;
9191 dgst_pos1 = 1;
9192 dgst_pos2 = 2;
9193 dgst_pos3 = 3;
9194 break;
9195
9196 case 7600: hash_type = HASH_TYPE_SHA1;
9197 salt_type = SALT_TYPE_INTERN;
9198 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9199 opts_type = OPTS_TYPE_PT_GENERATE_BE
9200 | OPTS_TYPE_PT_ADD80
9201 | OPTS_TYPE_PT_ADDBITS15;
9202 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9203 dgst_size = DGST_SIZE_4_5;
9204 parse_func = redmine_parse_hash;
9205 sort_by_digest = sort_by_digest_4_5;
9206 opti_type = OPTI_TYPE_ZERO_BYTE
9207 | OPTI_TYPE_PRECOMPUTE_INIT
9208 | OPTI_TYPE_EARLY_SKIP
9209 | OPTI_TYPE_NOT_ITERATED
9210 | OPTI_TYPE_PREPENDED_SALT;
9211 dgst_pos0 = 3;
9212 dgst_pos1 = 4;
9213 dgst_pos2 = 2;
9214 dgst_pos3 = 1;
9215 break;
9216
9217 case 7700: hash_type = HASH_TYPE_SAPB;
9218 salt_type = SALT_TYPE_EMBEDDED;
9219 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9220 opts_type = OPTS_TYPE_PT_GENERATE_LE
9221 | OPTS_TYPE_PT_UPPER
9222 | OPTS_TYPE_ST_UPPER;
9223 kern_type = KERN_TYPE_SAPB;
9224 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9225 parse_func = sapb_parse_hash;
9226 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9227 opti_type = OPTI_TYPE_ZERO_BYTE
9228 | OPTI_TYPE_PRECOMPUTE_INIT
9229 | OPTI_TYPE_NOT_ITERATED;
9230 dgst_pos0 = 0;
9231 dgst_pos1 = 1;
9232 dgst_pos2 = 2;
9233 dgst_pos3 = 3;
9234 break;
9235
9236 case 7800: hash_type = HASH_TYPE_SAPG;
9237 salt_type = SALT_TYPE_EMBEDDED;
9238 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9239 opts_type = OPTS_TYPE_PT_GENERATE_BE
9240 | OPTS_TYPE_ST_ADD80
9241 | OPTS_TYPE_ST_UPPER;
9242 kern_type = KERN_TYPE_SAPG;
9243 dgst_size = DGST_SIZE_4_5;
9244 parse_func = sapg_parse_hash;
9245 sort_by_digest = sort_by_digest_4_5;
9246 opti_type = OPTI_TYPE_ZERO_BYTE
9247 | OPTI_TYPE_PRECOMPUTE_INIT
9248 | OPTI_TYPE_NOT_ITERATED;
9249 dgst_pos0 = 3;
9250 dgst_pos1 = 4;
9251 dgst_pos2 = 2;
9252 dgst_pos3 = 1;
9253 break;
9254
9255 case 7900: hash_type = HASH_TYPE_SHA512;
9256 salt_type = SALT_TYPE_EMBEDDED;
9257 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9258 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9259 kern_type = KERN_TYPE_DRUPAL7;
9260 dgst_size = DGST_SIZE_8_8;
9261 parse_func = drupal7_parse_hash;
9262 sort_by_digest = sort_by_digest_8_8;
9263 opti_type = OPTI_TYPE_ZERO_BYTE
9264 | OPTI_TYPE_USES_BITS_64;
9265 dgst_pos0 = 0;
9266 dgst_pos1 = 1;
9267 dgst_pos2 = 2;
9268 dgst_pos3 = 3;
9269 break;
9270
9271 case 8000: hash_type = HASH_TYPE_SHA256;
9272 salt_type = SALT_TYPE_EMBEDDED;
9273 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9274 opts_type = OPTS_TYPE_PT_GENERATE_BE
9275 | OPTS_TYPE_PT_UNICODE
9276 | OPTS_TYPE_ST_ADD80
9277 | OPTS_TYPE_ST_HEX;
9278 kern_type = KERN_TYPE_SYBASEASE;
9279 dgst_size = DGST_SIZE_4_8;
9280 parse_func = sybasease_parse_hash;
9281 sort_by_digest = sort_by_digest_4_8;
9282 opti_type = OPTI_TYPE_ZERO_BYTE
9283 | OPTI_TYPE_PRECOMPUTE_INIT
9284 | OPTI_TYPE_EARLY_SKIP
9285 | OPTI_TYPE_NOT_ITERATED
9286 | OPTI_TYPE_RAW_HASH;
9287 dgst_pos0 = 3;
9288 dgst_pos1 = 7;
9289 dgst_pos2 = 2;
9290 dgst_pos3 = 6;
9291 break;
9292
9293 case 8100: hash_type = HASH_TYPE_SHA1;
9294 salt_type = SALT_TYPE_EMBEDDED;
9295 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9296 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9297 kern_type = KERN_TYPE_NETSCALER;
9298 dgst_size = DGST_SIZE_4_5;
9299 parse_func = netscaler_parse_hash;
9300 sort_by_digest = sort_by_digest_4_5;
9301 opti_type = OPTI_TYPE_ZERO_BYTE
9302 | OPTI_TYPE_PRECOMPUTE_INIT
9303 | OPTI_TYPE_PRECOMPUTE_MERKLE
9304 | OPTI_TYPE_EARLY_SKIP
9305 | OPTI_TYPE_NOT_ITERATED
9306 | OPTI_TYPE_PREPENDED_SALT
9307 | OPTI_TYPE_RAW_HASH;
9308 dgst_pos0 = 3;
9309 dgst_pos1 = 4;
9310 dgst_pos2 = 2;
9311 dgst_pos3 = 1;
9312 break;
9313
9314 case 8200: hash_type = HASH_TYPE_SHA256;
9315 salt_type = SALT_TYPE_EMBEDDED;
9316 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9317 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9318 kern_type = KERN_TYPE_CLOUDKEY;
9319 dgst_size = DGST_SIZE_4_8;
9320 parse_func = cloudkey_parse_hash;
9321 sort_by_digest = sort_by_digest_4_8;
9322 opti_type = OPTI_TYPE_ZERO_BYTE;
9323 dgst_pos0 = 0;
9324 dgst_pos1 = 1;
9325 dgst_pos2 = 2;
9326 dgst_pos3 = 3;
9327 break;
9328
9329 case 8300: hash_type = HASH_TYPE_SHA1;
9330 salt_type = SALT_TYPE_EMBEDDED;
9331 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9332 opts_type = OPTS_TYPE_PT_GENERATE_BE
9333 | OPTS_TYPE_ST_HEX
9334 | OPTS_TYPE_ST_ADD80;
9335 kern_type = KERN_TYPE_NSEC3;
9336 dgst_size = DGST_SIZE_4_5;
9337 parse_func = nsec3_parse_hash;
9338 sort_by_digest = sort_by_digest_4_5;
9339 opti_type = OPTI_TYPE_ZERO_BYTE;
9340 dgst_pos0 = 3;
9341 dgst_pos1 = 4;
9342 dgst_pos2 = 2;
9343 dgst_pos3 = 1;
9344 break;
9345
9346 case 8400: hash_type = HASH_TYPE_SHA1;
9347 salt_type = SALT_TYPE_INTERN;
9348 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9349 opts_type = OPTS_TYPE_PT_GENERATE_BE
9350 | OPTS_TYPE_PT_ADD80
9351 | OPTS_TYPE_PT_ADDBITS15;
9352 kern_type = KERN_TYPE_WBB3;
9353 dgst_size = DGST_SIZE_4_5;
9354 parse_func = wbb3_parse_hash;
9355 sort_by_digest = sort_by_digest_4_5;
9356 opti_type = OPTI_TYPE_ZERO_BYTE
9357 | OPTI_TYPE_PRECOMPUTE_INIT
9358 | OPTI_TYPE_NOT_ITERATED;
9359 dgst_pos0 = 3;
9360 dgst_pos1 = 4;
9361 dgst_pos2 = 2;
9362 dgst_pos3 = 1;
9363 break;
9364
9365 case 8500: hash_type = HASH_TYPE_DESRACF;
9366 salt_type = SALT_TYPE_EMBEDDED;
9367 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9368 opts_type = OPTS_TYPE_PT_GENERATE_LE
9369 | OPTS_TYPE_ST_UPPER;
9370 kern_type = KERN_TYPE_RACF;
9371 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9372 parse_func = racf_parse_hash;
9373 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9374 opti_type = OPTI_TYPE_ZERO_BYTE
9375 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9376 dgst_pos0 = 0;
9377 dgst_pos1 = 1;
9378 dgst_pos2 = 2;
9379 dgst_pos3 = 3;
9380 break;
9381
9382 case 8600: hash_type = HASH_TYPE_LOTUS5;
9383 salt_type = SALT_TYPE_NONE;
9384 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9385 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9386 kern_type = KERN_TYPE_LOTUS5;
9387 dgst_size = DGST_SIZE_4_4;
9388 parse_func = lotus5_parse_hash;
9389 sort_by_digest = sort_by_digest_4_4;
9390 opti_type = OPTI_TYPE_EARLY_SKIP
9391 | OPTI_TYPE_NOT_ITERATED
9392 | OPTI_TYPE_NOT_SALTED
9393 | OPTI_TYPE_RAW_HASH;
9394 dgst_pos0 = 0;
9395 dgst_pos1 = 1;
9396 dgst_pos2 = 2;
9397 dgst_pos3 = 3;
9398 break;
9399
9400 case 8700: hash_type = HASH_TYPE_LOTUS6;
9401 salt_type = SALT_TYPE_EMBEDDED;
9402 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9403 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9404 kern_type = KERN_TYPE_LOTUS6;
9405 dgst_size = DGST_SIZE_4_4;
9406 parse_func = lotus6_parse_hash;
9407 sort_by_digest = sort_by_digest_4_4;
9408 opti_type = OPTI_TYPE_EARLY_SKIP
9409 | OPTI_TYPE_NOT_ITERATED
9410 | OPTI_TYPE_RAW_HASH;
9411 dgst_pos0 = 0;
9412 dgst_pos1 = 1;
9413 dgst_pos2 = 2;
9414 dgst_pos3 = 3;
9415 break;
9416
9417 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9418 salt_type = SALT_TYPE_EMBEDDED;
9419 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9420 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9421 kern_type = KERN_TYPE_ANDROIDFDE;
9422 dgst_size = DGST_SIZE_4_4;
9423 parse_func = androidfde_parse_hash;
9424 sort_by_digest = sort_by_digest_4_4;
9425 opti_type = OPTI_TYPE_ZERO_BYTE;
9426 dgst_pos0 = 0;
9427 dgst_pos1 = 1;
9428 dgst_pos2 = 2;
9429 dgst_pos3 = 3;
9430 break;
9431
9432 case 8900: hash_type = HASH_TYPE_SCRYPT;
9433 salt_type = SALT_TYPE_EMBEDDED;
9434 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9435 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9436 kern_type = KERN_TYPE_SCRYPT;
9437 dgst_size = DGST_SIZE_4_8;
9438 parse_func = scrypt_parse_hash;
9439 sort_by_digest = sort_by_digest_4_8;
9440 opti_type = OPTI_TYPE_ZERO_BYTE;
9441 dgst_pos0 = 0;
9442 dgst_pos1 = 1;
9443 dgst_pos2 = 2;
9444 dgst_pos3 = 3;
9445 break;
9446
9447 case 9000: hash_type = HASH_TYPE_SHA1;
9448 salt_type = SALT_TYPE_EMBEDDED;
9449 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9450 opts_type = OPTS_TYPE_PT_GENERATE_LE
9451 | OPTS_TYPE_ST_GENERATE_LE;
9452 kern_type = KERN_TYPE_PSAFE2;
9453 dgst_size = DGST_SIZE_4_5;
9454 parse_func = psafe2_parse_hash;
9455 sort_by_digest = sort_by_digest_4_5;
9456 opti_type = OPTI_TYPE_ZERO_BYTE;
9457 dgst_pos0 = 0;
9458 dgst_pos1 = 1;
9459 dgst_pos2 = 2;
9460 dgst_pos3 = 3;
9461 break;
9462
9463 case 9100: hash_type = HASH_TYPE_LOTUS8;
9464 salt_type = SALT_TYPE_EMBEDDED;
9465 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9466 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9467 kern_type = KERN_TYPE_LOTUS8;
9468 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9469 parse_func = lotus8_parse_hash;
9470 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9471 opti_type = OPTI_TYPE_ZERO_BYTE;
9472 dgst_pos0 = 0;
9473 dgst_pos1 = 1;
9474 dgst_pos2 = 2;
9475 dgst_pos3 = 3;
9476 break;
9477
9478 case 9200: hash_type = HASH_TYPE_SHA256;
9479 salt_type = SALT_TYPE_EMBEDDED;
9480 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9481 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9482 kern_type = KERN_TYPE_PBKDF2_SHA256;
9483 dgst_size = DGST_SIZE_4_32;
9484 parse_func = cisco8_parse_hash;
9485 sort_by_digest = sort_by_digest_4_32;
9486 opti_type = OPTI_TYPE_ZERO_BYTE;
9487 dgst_pos0 = 0;
9488 dgst_pos1 = 1;
9489 dgst_pos2 = 2;
9490 dgst_pos3 = 3;
9491 break;
9492
9493 case 9300: hash_type = HASH_TYPE_SCRYPT;
9494 salt_type = SALT_TYPE_EMBEDDED;
9495 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9496 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9497 kern_type = KERN_TYPE_SCRYPT;
9498 dgst_size = DGST_SIZE_4_8;
9499 parse_func = cisco9_parse_hash;
9500 sort_by_digest = sort_by_digest_4_8;
9501 opti_type = OPTI_TYPE_ZERO_BYTE;
9502 dgst_pos0 = 0;
9503 dgst_pos1 = 1;
9504 dgst_pos2 = 2;
9505 dgst_pos3 = 3;
9506 break;
9507
9508 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9509 salt_type = SALT_TYPE_EMBEDDED;
9510 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9511 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9512 kern_type = KERN_TYPE_OFFICE2007;
9513 dgst_size = DGST_SIZE_4_4;
9514 parse_func = office2007_parse_hash;
9515 sort_by_digest = sort_by_digest_4_4;
9516 opti_type = OPTI_TYPE_ZERO_BYTE;
9517 dgst_pos0 = 0;
9518 dgst_pos1 = 1;
9519 dgst_pos2 = 2;
9520 dgst_pos3 = 3;
9521 break;
9522
9523 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9524 salt_type = SALT_TYPE_EMBEDDED;
9525 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9526 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9527 kern_type = KERN_TYPE_OFFICE2010;
9528 dgst_size = DGST_SIZE_4_4;
9529 parse_func = office2010_parse_hash;
9530 sort_by_digest = sort_by_digest_4_4;
9531 opti_type = OPTI_TYPE_ZERO_BYTE;
9532 dgst_pos0 = 0;
9533 dgst_pos1 = 1;
9534 dgst_pos2 = 2;
9535 dgst_pos3 = 3;
9536 break;
9537
9538 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9539 salt_type = SALT_TYPE_EMBEDDED;
9540 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9541 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9542 kern_type = KERN_TYPE_OFFICE2013;
9543 dgst_size = DGST_SIZE_4_4;
9544 parse_func = office2013_parse_hash;
9545 sort_by_digest = sort_by_digest_4_4;
9546 opti_type = OPTI_TYPE_ZERO_BYTE;
9547 dgst_pos0 = 0;
9548 dgst_pos1 = 1;
9549 dgst_pos2 = 2;
9550 dgst_pos3 = 3;
9551 break;
9552
9553 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9554 salt_type = SALT_TYPE_EMBEDDED;
9555 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9556 opts_type = OPTS_TYPE_PT_GENERATE_LE
9557 | OPTS_TYPE_PT_ADD80
9558 | OPTS_TYPE_PT_UNICODE;
9559 kern_type = KERN_TYPE_OLDOFFICE01;
9560 dgst_size = DGST_SIZE_4_4;
9561 parse_func = oldoffice01_parse_hash;
9562 sort_by_digest = sort_by_digest_4_4;
9563 opti_type = OPTI_TYPE_ZERO_BYTE
9564 | OPTI_TYPE_PRECOMPUTE_INIT
9565 | OPTI_TYPE_NOT_ITERATED;
9566 dgst_pos0 = 0;
9567 dgst_pos1 = 1;
9568 dgst_pos2 = 2;
9569 dgst_pos3 = 3;
9570 break;
9571
9572 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9573 salt_type = SALT_TYPE_EMBEDDED;
9574 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9575 opts_type = OPTS_TYPE_PT_GENERATE_LE
9576 | OPTS_TYPE_PT_ADD80;
9577 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9578 dgst_size = DGST_SIZE_4_4;
9579 parse_func = oldoffice01cm1_parse_hash;
9580 sort_by_digest = sort_by_digest_4_4;
9581 opti_type = OPTI_TYPE_ZERO_BYTE
9582 | OPTI_TYPE_PRECOMPUTE_INIT
9583 | OPTI_TYPE_NOT_ITERATED;
9584 dgst_pos0 = 0;
9585 dgst_pos1 = 1;
9586 dgst_pos2 = 2;
9587 dgst_pos3 = 3;
9588 break;
9589
9590 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9591 salt_type = SALT_TYPE_EMBEDDED;
9592 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9593 opts_type = OPTS_TYPE_PT_GENERATE_LE
9594 | OPTS_TYPE_PT_ADD80
9595 | OPTS_TYPE_PT_UNICODE
9596 | OPTS_TYPE_PT_NEVERCRACK;
9597 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9598 dgst_size = DGST_SIZE_4_4;
9599 parse_func = oldoffice01cm2_parse_hash;
9600 sort_by_digest = sort_by_digest_4_4;
9601 opti_type = OPTI_TYPE_ZERO_BYTE
9602 | OPTI_TYPE_PRECOMPUTE_INIT
9603 | OPTI_TYPE_NOT_ITERATED;
9604 dgst_pos0 = 0;
9605 dgst_pos1 = 1;
9606 dgst_pos2 = 2;
9607 dgst_pos3 = 3;
9608 break;
9609
9610 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9611 salt_type = SALT_TYPE_EMBEDDED;
9612 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9613 opts_type = OPTS_TYPE_PT_GENERATE_BE
9614 | OPTS_TYPE_PT_ADD80
9615 | OPTS_TYPE_PT_UNICODE;
9616 kern_type = KERN_TYPE_OLDOFFICE34;
9617 dgst_size = DGST_SIZE_4_4;
9618 parse_func = oldoffice34_parse_hash;
9619 sort_by_digest = sort_by_digest_4_4;
9620 opti_type = OPTI_TYPE_ZERO_BYTE
9621 | OPTI_TYPE_PRECOMPUTE_INIT
9622 | OPTI_TYPE_NOT_ITERATED;
9623 dgst_pos0 = 0;
9624 dgst_pos1 = 1;
9625 dgst_pos2 = 2;
9626 dgst_pos3 = 3;
9627 break;
9628
9629 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9630 salt_type = SALT_TYPE_EMBEDDED;
9631 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9632 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9633 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9634 dgst_size = DGST_SIZE_4_4;
9635 parse_func = oldoffice34cm1_parse_hash;
9636 sort_by_digest = sort_by_digest_4_4;
9637 opti_type = OPTI_TYPE_ZERO_BYTE
9638 | OPTI_TYPE_PRECOMPUTE_INIT
9639 | OPTI_TYPE_NOT_ITERATED;
9640 dgst_pos0 = 0;
9641 dgst_pos1 = 1;
9642 dgst_pos2 = 2;
9643 dgst_pos3 = 3;
9644 break;
9645
9646 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9647 salt_type = SALT_TYPE_EMBEDDED;
9648 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9649 opts_type = OPTS_TYPE_PT_GENERATE_BE
9650 | OPTS_TYPE_PT_ADD80
9651 | OPTS_TYPE_PT_UNICODE
9652 | OPTS_TYPE_PT_NEVERCRACK;
9653 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9654 dgst_size = DGST_SIZE_4_4;
9655 parse_func = oldoffice34cm2_parse_hash;
9656 sort_by_digest = sort_by_digest_4_4;
9657 opti_type = OPTI_TYPE_ZERO_BYTE
9658 | OPTI_TYPE_PRECOMPUTE_INIT
9659 | OPTI_TYPE_NOT_ITERATED;
9660 dgst_pos0 = 0;
9661 dgst_pos1 = 1;
9662 dgst_pos2 = 2;
9663 dgst_pos3 = 3;
9664 break;
9665
9666 case 9900: hash_type = HASH_TYPE_MD5;
9667 salt_type = SALT_TYPE_NONE;
9668 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9669 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9670 kern_type = KERN_TYPE_RADMIN2;
9671 dgst_size = DGST_SIZE_4_4;
9672 parse_func = radmin2_parse_hash;
9673 sort_by_digest = sort_by_digest_4_4;
9674 opti_type = OPTI_TYPE_ZERO_BYTE
9675 | OPTI_TYPE_PRECOMPUTE_INIT
9676 | OPTI_TYPE_EARLY_SKIP
9677 | OPTI_TYPE_NOT_ITERATED
9678 | OPTI_TYPE_NOT_SALTED;
9679 dgst_pos0 = 0;
9680 dgst_pos1 = 3;
9681 dgst_pos2 = 2;
9682 dgst_pos3 = 1;
9683 break;
9684
9685 case 10000: hash_type = HASH_TYPE_SHA256;
9686 salt_type = SALT_TYPE_EMBEDDED;
9687 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9688 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9689 kern_type = KERN_TYPE_PBKDF2_SHA256;
9690 dgst_size = DGST_SIZE_4_32;
9691 parse_func = djangopbkdf2_parse_hash;
9692 sort_by_digest = sort_by_digest_4_32;
9693 opti_type = OPTI_TYPE_ZERO_BYTE;
9694 dgst_pos0 = 0;
9695 dgst_pos1 = 1;
9696 dgst_pos2 = 2;
9697 dgst_pos3 = 3;
9698 break;
9699
9700 case 10100: hash_type = HASH_TYPE_SIPHASH;
9701 salt_type = SALT_TYPE_EMBEDDED;
9702 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9703 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9704 kern_type = KERN_TYPE_SIPHASH;
9705 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9706 parse_func = siphash_parse_hash;
9707 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9708 opti_type = OPTI_TYPE_ZERO_BYTE
9709 | OPTI_TYPE_NOT_ITERATED
9710 | OPTI_TYPE_RAW_HASH;
9711 dgst_pos0 = 0;
9712 dgst_pos1 = 1;
9713 dgst_pos2 = 2;
9714 dgst_pos3 = 3;
9715 break;
9716
9717 case 10200: hash_type = HASH_TYPE_MD5;
9718 salt_type = SALT_TYPE_EMBEDDED;
9719 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9720 opts_type = OPTS_TYPE_PT_GENERATE_LE
9721 | OPTS_TYPE_ST_ADD80
9722 | OPTS_TYPE_ST_ADDBITS14;
9723 kern_type = KERN_TYPE_HMACMD5_PW;
9724 dgst_size = DGST_SIZE_4_4;
9725 parse_func = crammd5_parse_hash;
9726 sort_by_digest = sort_by_digest_4_4;
9727 opti_type = OPTI_TYPE_ZERO_BYTE
9728 | OPTI_TYPE_NOT_ITERATED;
9729 dgst_pos0 = 0;
9730 dgst_pos1 = 3;
9731 dgst_pos2 = 2;
9732 dgst_pos3 = 1;
9733 break;
9734
9735 case 10300: hash_type = HASH_TYPE_SHA1;
9736 salt_type = SALT_TYPE_EMBEDDED;
9737 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9738 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9739 kern_type = KERN_TYPE_SAPH_SHA1;
9740 dgst_size = DGST_SIZE_4_5;
9741 parse_func = saph_sha1_parse_hash;
9742 sort_by_digest = sort_by_digest_4_5;
9743 opti_type = OPTI_TYPE_ZERO_BYTE;
9744 dgst_pos0 = 0;
9745 dgst_pos1 = 1;
9746 dgst_pos2 = 2;
9747 dgst_pos3 = 3;
9748 break;
9749
9750 case 10400: hash_type = HASH_TYPE_PDFU16;
9751 salt_type = SALT_TYPE_EMBEDDED;
9752 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9753 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9754 kern_type = KERN_TYPE_PDF11;
9755 dgst_size = DGST_SIZE_4_4;
9756 parse_func = pdf11_parse_hash;
9757 sort_by_digest = sort_by_digest_4_4;
9758 opti_type = OPTI_TYPE_ZERO_BYTE
9759 | OPTI_TYPE_NOT_ITERATED;
9760 dgst_pos0 = 0;
9761 dgst_pos1 = 1;
9762 dgst_pos2 = 2;
9763 dgst_pos3 = 3;
9764 break;
9765
9766 case 10410: hash_type = HASH_TYPE_PDFU16;
9767 salt_type = SALT_TYPE_EMBEDDED;
9768 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9769 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9770 kern_type = KERN_TYPE_PDF11CM1;
9771 dgst_size = DGST_SIZE_4_4;
9772 parse_func = pdf11cm1_parse_hash;
9773 sort_by_digest = sort_by_digest_4_4;
9774 opti_type = OPTI_TYPE_ZERO_BYTE
9775 | OPTI_TYPE_NOT_ITERATED;
9776 dgst_pos0 = 0;
9777 dgst_pos1 = 1;
9778 dgst_pos2 = 2;
9779 dgst_pos3 = 3;
9780 break;
9781
9782 case 10420: hash_type = HASH_TYPE_PDFU16;
9783 salt_type = SALT_TYPE_EMBEDDED;
9784 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9785 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9786 kern_type = KERN_TYPE_PDF11CM2;
9787 dgst_size = DGST_SIZE_4_4;
9788 parse_func = pdf11cm2_parse_hash;
9789 sort_by_digest = sort_by_digest_4_4;
9790 opti_type = OPTI_TYPE_ZERO_BYTE
9791 | OPTI_TYPE_NOT_ITERATED;
9792 dgst_pos0 = 0;
9793 dgst_pos1 = 1;
9794 dgst_pos2 = 2;
9795 dgst_pos3 = 3;
9796 break;
9797
9798 case 10500: hash_type = HASH_TYPE_PDFU16;
9799 salt_type = SALT_TYPE_EMBEDDED;
9800 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9801 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9802 kern_type = KERN_TYPE_PDF14;
9803 dgst_size = DGST_SIZE_4_4;
9804 parse_func = pdf14_parse_hash;
9805 sort_by_digest = sort_by_digest_4_4;
9806 opti_type = OPTI_TYPE_ZERO_BYTE
9807 | OPTI_TYPE_NOT_ITERATED;
9808 dgst_pos0 = 0;
9809 dgst_pos1 = 1;
9810 dgst_pos2 = 2;
9811 dgst_pos3 = 3;
9812 break;
9813
9814 case 10600: hash_type = HASH_TYPE_SHA256;
9815 salt_type = SALT_TYPE_EMBEDDED;
9816 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9817 opts_type = OPTS_TYPE_PT_GENERATE_BE
9818 | OPTS_TYPE_ST_ADD80
9819 | OPTS_TYPE_ST_ADDBITS15
9820 | OPTS_TYPE_HASH_COPY;
9821 kern_type = KERN_TYPE_SHA256_PWSLT;
9822 dgst_size = DGST_SIZE_4_8;
9823 parse_func = pdf17l3_parse_hash;
9824 sort_by_digest = sort_by_digest_4_8;
9825 opti_type = OPTI_TYPE_ZERO_BYTE
9826 | OPTI_TYPE_PRECOMPUTE_INIT
9827 | OPTI_TYPE_PRECOMPUTE_MERKLE
9828 | OPTI_TYPE_EARLY_SKIP
9829 | OPTI_TYPE_NOT_ITERATED
9830 | OPTI_TYPE_APPENDED_SALT
9831 | OPTI_TYPE_RAW_HASH;
9832 dgst_pos0 = 3;
9833 dgst_pos1 = 7;
9834 dgst_pos2 = 2;
9835 dgst_pos3 = 6;
9836 break;
9837
9838 case 10700: hash_type = HASH_TYPE_PDFU32;
9839 salt_type = SALT_TYPE_EMBEDDED;
9840 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9841 opts_type = OPTS_TYPE_PT_GENERATE_LE
9842 | OPTS_TYPE_HASH_COPY;
9843 kern_type = KERN_TYPE_PDF17L8;
9844 dgst_size = DGST_SIZE_4_8;
9845 parse_func = pdf17l8_parse_hash;
9846 sort_by_digest = sort_by_digest_4_8;
9847 opti_type = OPTI_TYPE_ZERO_BYTE
9848 | OPTI_TYPE_NOT_ITERATED;
9849 dgst_pos0 = 0;
9850 dgst_pos1 = 1;
9851 dgst_pos2 = 2;
9852 dgst_pos3 = 3;
9853 break;
9854
9855 case 10800: hash_type = HASH_TYPE_SHA384;
9856 salt_type = SALT_TYPE_NONE;
9857 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9858 opts_type = OPTS_TYPE_PT_GENERATE_BE
9859 | OPTS_TYPE_PT_ADD80
9860 | OPTS_TYPE_PT_ADDBITS15;
9861 kern_type = KERN_TYPE_SHA384;
9862 dgst_size = DGST_SIZE_8_8;
9863 parse_func = sha384_parse_hash;
9864 sort_by_digest = sort_by_digest_8_8;
9865 opti_type = OPTI_TYPE_ZERO_BYTE
9866 | OPTI_TYPE_PRECOMPUTE_INIT
9867 | OPTI_TYPE_PRECOMPUTE_MERKLE
9868 | OPTI_TYPE_EARLY_SKIP
9869 | OPTI_TYPE_NOT_ITERATED
9870 | OPTI_TYPE_NOT_SALTED
9871 | OPTI_TYPE_USES_BITS_64
9872 | OPTI_TYPE_RAW_HASH;
9873 dgst_pos0 = 6;
9874 dgst_pos1 = 7;
9875 dgst_pos2 = 4;
9876 dgst_pos3 = 5;
9877 break;
9878
9879 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9880 salt_type = SALT_TYPE_EMBEDDED;
9881 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9882 opts_type = OPTS_TYPE_PT_GENERATE_LE
9883 | OPTS_TYPE_ST_BASE64
9884 | OPTS_TYPE_HASH_COPY;
9885 kern_type = KERN_TYPE_PBKDF2_SHA256;
9886 dgst_size = DGST_SIZE_4_32;
9887 parse_func = pbkdf2_sha256_parse_hash;
9888 sort_by_digest = sort_by_digest_4_32;
9889 opti_type = OPTI_TYPE_ZERO_BYTE;
9890 dgst_pos0 = 0;
9891 dgst_pos1 = 1;
9892 dgst_pos2 = 2;
9893 dgst_pos3 = 3;
9894 break;
9895
9896 case 11000: hash_type = HASH_TYPE_MD5;
9897 salt_type = SALT_TYPE_INTERN;
9898 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9899 opts_type = OPTS_TYPE_PT_GENERATE_LE
9900 | OPTS_TYPE_PT_ADD80;
9901 kern_type = KERN_TYPE_PRESTASHOP;
9902 dgst_size = DGST_SIZE_4_4;
9903 parse_func = prestashop_parse_hash;
9904 sort_by_digest = sort_by_digest_4_4;
9905 opti_type = OPTI_TYPE_ZERO_BYTE
9906 | OPTI_TYPE_PRECOMPUTE_INIT
9907 | OPTI_TYPE_NOT_ITERATED
9908 | OPTI_TYPE_PREPENDED_SALT;
9909 dgst_pos0 = 0;
9910 dgst_pos1 = 3;
9911 dgst_pos2 = 2;
9912 dgst_pos3 = 1;
9913 break;
9914
9915 case 11100: hash_type = HASH_TYPE_MD5;
9916 salt_type = SALT_TYPE_EMBEDDED;
9917 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9918 opts_type = OPTS_TYPE_PT_GENERATE_LE
9919 | OPTS_TYPE_ST_ADD80;
9920 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9921 dgst_size = DGST_SIZE_4_4;
9922 parse_func = postgresql_auth_parse_hash;
9923 sort_by_digest = sort_by_digest_4_4;
9924 opti_type = OPTI_TYPE_ZERO_BYTE
9925 | OPTI_TYPE_PRECOMPUTE_INIT
9926 | OPTI_TYPE_PRECOMPUTE_MERKLE
9927 | OPTI_TYPE_EARLY_SKIP;
9928 dgst_pos0 = 0;
9929 dgst_pos1 = 3;
9930 dgst_pos2 = 2;
9931 dgst_pos3 = 1;
9932 break;
9933
9934 case 11200: hash_type = HASH_TYPE_SHA1;
9935 salt_type = SALT_TYPE_EMBEDDED;
9936 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9937 opts_type = OPTS_TYPE_PT_GENERATE_BE
9938 | OPTS_TYPE_PT_ADD80
9939 | OPTS_TYPE_ST_HEX;
9940 kern_type = KERN_TYPE_MYSQL_AUTH;
9941 dgst_size = DGST_SIZE_4_5;
9942 parse_func = mysql_auth_parse_hash;
9943 sort_by_digest = sort_by_digest_4_5;
9944 opti_type = OPTI_TYPE_ZERO_BYTE
9945 | OPTI_TYPE_EARLY_SKIP;
9946 dgst_pos0 = 3;
9947 dgst_pos1 = 4;
9948 dgst_pos2 = 2;
9949 dgst_pos3 = 1;
9950 break;
9951
9952 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9953 salt_type = SALT_TYPE_EMBEDDED;
9954 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9955 opts_type = OPTS_TYPE_PT_GENERATE_LE
9956 | OPTS_TYPE_ST_HEX
9957 | OPTS_TYPE_ST_ADD80;
9958 kern_type = KERN_TYPE_BITCOIN_WALLET;
9959 dgst_size = DGST_SIZE_4_4;
9960 parse_func = bitcoin_wallet_parse_hash;
9961 sort_by_digest = sort_by_digest_4_4;
9962 opti_type = OPTI_TYPE_ZERO_BYTE;
9963 dgst_pos0 = 0;
9964 dgst_pos1 = 1;
9965 dgst_pos2 = 2;
9966 dgst_pos3 = 3;
9967 break;
9968
9969 case 11400: hash_type = HASH_TYPE_MD5;
9970 salt_type = SALT_TYPE_EMBEDDED;
9971 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9972 opts_type = OPTS_TYPE_PT_GENERATE_LE
9973 | OPTS_TYPE_PT_ADD80
9974 | OPTS_TYPE_HASH_COPY;
9975 kern_type = KERN_TYPE_SIP_AUTH;
9976 dgst_size = DGST_SIZE_4_4;
9977 parse_func = sip_auth_parse_hash;
9978 sort_by_digest = sort_by_digest_4_4;
9979 opti_type = OPTI_TYPE_ZERO_BYTE;
9980 dgst_pos0 = 0;
9981 dgst_pos1 = 3;
9982 dgst_pos2 = 2;
9983 dgst_pos3 = 1;
9984 break;
9985
9986 case 11500: hash_type = HASH_TYPE_CRC32;
9987 salt_type = SALT_TYPE_INTERN;
9988 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9989 opts_type = OPTS_TYPE_PT_GENERATE_LE
9990 | OPTS_TYPE_ST_GENERATE_LE
9991 | OPTS_TYPE_ST_HEX;
9992 kern_type = KERN_TYPE_CRC32;
9993 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9994 parse_func = crc32_parse_hash;
9995 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9996 opti_type = OPTI_TYPE_ZERO_BYTE;
9997 dgst_pos0 = 0;
9998 dgst_pos1 = 1;
9999 dgst_pos2 = 2;
10000 dgst_pos3 = 3;
10001 break;
10002
10003 case 11600: hash_type = HASH_TYPE_AES;
10004 salt_type = SALT_TYPE_EMBEDDED;
10005 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10006 opts_type = OPTS_TYPE_PT_GENERATE_LE
10007 | OPTS_TYPE_PT_NEVERCRACK;
10008 kern_type = KERN_TYPE_SEVEN_ZIP;
10009 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10010 parse_func = seven_zip_parse_hash;
10011 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10012 opti_type = OPTI_TYPE_ZERO_BYTE;
10013 dgst_pos0 = 0;
10014 dgst_pos1 = 1;
10015 dgst_pos2 = 2;
10016 dgst_pos3 = 3;
10017 break;
10018
10019 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10020 salt_type = SALT_TYPE_NONE;
10021 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10022 opts_type = OPTS_TYPE_PT_GENERATE_LE
10023 | OPTS_TYPE_PT_ADD01;
10024 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10025 dgst_size = DGST_SIZE_4_8;
10026 parse_func = gost2012sbog_256_parse_hash;
10027 sort_by_digest = sort_by_digest_4_8;
10028 opti_type = OPTI_TYPE_ZERO_BYTE;
10029 dgst_pos0 = 0;
10030 dgst_pos1 = 1;
10031 dgst_pos2 = 2;
10032 dgst_pos3 = 3;
10033 break;
10034
10035 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10036 salt_type = SALT_TYPE_NONE;
10037 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10038 opts_type = OPTS_TYPE_PT_GENERATE_LE
10039 | OPTS_TYPE_PT_ADD01;
10040 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10041 dgst_size = DGST_SIZE_4_16;
10042 parse_func = gost2012sbog_512_parse_hash;
10043 sort_by_digest = sort_by_digest_4_16;
10044 opti_type = OPTI_TYPE_ZERO_BYTE;
10045 dgst_pos0 = 0;
10046 dgst_pos1 = 1;
10047 dgst_pos2 = 2;
10048 dgst_pos3 = 3;
10049 break;
10050
10051 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10052 salt_type = SALT_TYPE_EMBEDDED;
10053 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10054 opts_type = OPTS_TYPE_PT_GENERATE_LE
10055 | OPTS_TYPE_ST_BASE64
10056 | OPTS_TYPE_HASH_COPY;
10057 kern_type = KERN_TYPE_PBKDF2_MD5;
10058 dgst_size = DGST_SIZE_4_32;
10059 parse_func = pbkdf2_md5_parse_hash;
10060 sort_by_digest = sort_by_digest_4_32;
10061 opti_type = OPTI_TYPE_ZERO_BYTE;
10062 dgst_pos0 = 0;
10063 dgst_pos1 = 1;
10064 dgst_pos2 = 2;
10065 dgst_pos3 = 3;
10066 break;
10067
10068 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10069 salt_type = SALT_TYPE_EMBEDDED;
10070 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10071 opts_type = OPTS_TYPE_PT_GENERATE_LE
10072 | OPTS_TYPE_ST_BASE64
10073 | OPTS_TYPE_HASH_COPY;
10074 kern_type = KERN_TYPE_PBKDF2_SHA1;
10075 dgst_size = DGST_SIZE_4_32;
10076 parse_func = pbkdf2_sha1_parse_hash;
10077 sort_by_digest = sort_by_digest_4_32;
10078 opti_type = OPTI_TYPE_ZERO_BYTE;
10079 dgst_pos0 = 0;
10080 dgst_pos1 = 1;
10081 dgst_pos2 = 2;
10082 dgst_pos3 = 3;
10083 break;
10084
10085 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10086 salt_type = SALT_TYPE_EMBEDDED;
10087 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10088 opts_type = OPTS_TYPE_PT_GENERATE_LE
10089 | OPTS_TYPE_ST_BASE64
10090 | OPTS_TYPE_HASH_COPY;
10091 kern_type = KERN_TYPE_PBKDF2_SHA512;
10092 dgst_size = DGST_SIZE_8_16;
10093 parse_func = pbkdf2_sha512_parse_hash;
10094 sort_by_digest = sort_by_digest_8_16;
10095 opti_type = OPTI_TYPE_ZERO_BYTE
10096 | OPTI_TYPE_USES_BITS_64;
10097 dgst_pos0 = 0;
10098 dgst_pos1 = 1;
10099 dgst_pos2 = 2;
10100 dgst_pos3 = 3;
10101 break;
10102
10103 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10104 salt_type = SALT_TYPE_EMBEDDED;
10105 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10106 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10107 kern_type = KERN_TYPE_ECRYPTFS;
10108 dgst_size = DGST_SIZE_8_8;
10109 parse_func = ecryptfs_parse_hash;
10110 sort_by_digest = sort_by_digest_8_8;
10111 opti_type = OPTI_TYPE_ZERO_BYTE
10112 | OPTI_TYPE_USES_BITS_64;
10113 dgst_pos0 = 0;
10114 dgst_pos1 = 1;
10115 dgst_pos2 = 2;
10116 dgst_pos3 = 3;
10117 break;
10118
10119 case 12300: hash_type = HASH_TYPE_ORACLET;
10120 salt_type = SALT_TYPE_EMBEDDED;
10121 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10122 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10123 kern_type = KERN_TYPE_ORACLET;
10124 dgst_size = DGST_SIZE_8_16;
10125 parse_func = oraclet_parse_hash;
10126 sort_by_digest = sort_by_digest_8_16;
10127 opti_type = OPTI_TYPE_ZERO_BYTE
10128 | OPTI_TYPE_USES_BITS_64;
10129 dgst_pos0 = 0;
10130 dgst_pos1 = 1;
10131 dgst_pos2 = 2;
10132 dgst_pos3 = 3;
10133 break;
10134
10135 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10136 salt_type = SALT_TYPE_EMBEDDED;
10137 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10138 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10139 kern_type = KERN_TYPE_BSDICRYPT;
10140 dgst_size = DGST_SIZE_4_4;
10141 parse_func = bsdicrypt_parse_hash;
10142 sort_by_digest = sort_by_digest_4_4;
10143 opti_type = OPTI_TYPE_ZERO_BYTE
10144 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10145 dgst_pos0 = 0;
10146 dgst_pos1 = 1;
10147 dgst_pos2 = 2;
10148 dgst_pos3 = 3;
10149 break;
10150
10151 case 12500: hash_type = HASH_TYPE_RAR3HP;
10152 salt_type = SALT_TYPE_EMBEDDED;
10153 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10154 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10155 kern_type = KERN_TYPE_RAR3;
10156 dgst_size = DGST_SIZE_4_4;
10157 parse_func = rar3hp_parse_hash;
10158 sort_by_digest = sort_by_digest_4_4;
10159 opti_type = OPTI_TYPE_ZERO_BYTE;
10160 dgst_pos0 = 0;
10161 dgst_pos1 = 1;
10162 dgst_pos2 = 2;
10163 dgst_pos3 = 3;
10164 break;
10165
10166 case 12600: hash_type = HASH_TYPE_SHA256;
10167 salt_type = SALT_TYPE_INTERN;
10168 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10169 opts_type = OPTS_TYPE_PT_GENERATE_BE
10170 | OPTS_TYPE_PT_ADD80;
10171 kern_type = KERN_TYPE_CF10;
10172 dgst_size = DGST_SIZE_4_8;
10173 parse_func = cf10_parse_hash;
10174 sort_by_digest = sort_by_digest_4_8;
10175 opti_type = OPTI_TYPE_ZERO_BYTE
10176 | OPTI_TYPE_PRECOMPUTE_INIT
10177 | OPTI_TYPE_EARLY_SKIP
10178 | OPTI_TYPE_NOT_ITERATED;
10179 dgst_pos0 = 3;
10180 dgst_pos1 = 7;
10181 dgst_pos2 = 2;
10182 dgst_pos3 = 6;
10183 break;
10184
10185 case 12700: hash_type = HASH_TYPE_AES;
10186 salt_type = SALT_TYPE_EMBEDDED;
10187 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10188 opts_type = OPTS_TYPE_PT_GENERATE_LE
10189 | OPTS_TYPE_HASH_COPY;
10190 kern_type = KERN_TYPE_MYWALLET;
10191 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10192 parse_func = mywallet_parse_hash;
10193 sort_by_digest = sort_by_digest_4_5;
10194 opti_type = OPTI_TYPE_ZERO_BYTE;
10195 dgst_pos0 = 0;
10196 dgst_pos1 = 1;
10197 dgst_pos2 = 2;
10198 dgst_pos3 = 3;
10199 break;
10200
10201 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10202 salt_type = SALT_TYPE_EMBEDDED;
10203 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10204 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10205 kern_type = KERN_TYPE_MS_DRSR;
10206 dgst_size = DGST_SIZE_4_8;
10207 parse_func = ms_drsr_parse_hash;
10208 sort_by_digest = sort_by_digest_4_8;
10209 opti_type = OPTI_TYPE_ZERO_BYTE;
10210 dgst_pos0 = 0;
10211 dgst_pos1 = 1;
10212 dgst_pos2 = 2;
10213 dgst_pos3 = 3;
10214 break;
10215
10216 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10217 salt_type = SALT_TYPE_EMBEDDED;
10218 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10219 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10220 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10221 dgst_size = DGST_SIZE_4_8;
10222 parse_func = androidfde_samsung_parse_hash;
10223 sort_by_digest = sort_by_digest_4_8;
10224 opti_type = OPTI_TYPE_ZERO_BYTE;
10225 dgst_pos0 = 0;
10226 dgst_pos1 = 1;
10227 dgst_pos2 = 2;
10228 dgst_pos3 = 3;
10229 break;
10230
10231 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10232 salt_type = SALT_TYPE_EMBEDDED;
10233 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10234 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10235 kern_type = KERN_TYPE_RAR5;
10236 dgst_size = DGST_SIZE_4_4;
10237 parse_func = rar5_parse_hash;
10238 sort_by_digest = sort_by_digest_4_4;
10239 opti_type = OPTI_TYPE_ZERO_BYTE;
10240 dgst_pos0 = 0;
10241 dgst_pos1 = 1;
10242 dgst_pos2 = 2;
10243 dgst_pos3 = 3;
10244 break;
10245
10246 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10247 salt_type = SALT_TYPE_EMBEDDED;
10248 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10249 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10250 kern_type = KERN_TYPE_KRB5TGS;
10251 dgst_size = DGST_SIZE_4_4;
10252 parse_func = krb5tgs_parse_hash;
10253 sort_by_digest = sort_by_digest_4_4;
10254 opti_type = OPTI_TYPE_ZERO_BYTE
10255 | OPTI_TYPE_NOT_ITERATED;
10256 dgst_pos0 = 0;
10257 dgst_pos1 = 1;
10258 dgst_pos2 = 2;
10259 dgst_pos3 = 3;
10260 break;
10261
10262 case 13200: hash_type = HASH_TYPE_AES;
10263 salt_type = SALT_TYPE_EMBEDDED;
10264 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10265 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10266 kern_type = KERN_TYPE_AXCRYPT;
10267 dgst_size = DGST_SIZE_4_4;
10268 parse_func = axcrypt_parse_hash;
10269 sort_by_digest = sort_by_digest_4_4;
10270 opti_type = OPTI_TYPE_ZERO_BYTE;
10271 dgst_pos0 = 0;
10272 dgst_pos1 = 1;
10273 dgst_pos2 = 2;
10274 dgst_pos3 = 3;
10275 break;
10276
10277 case 13300: hash_type = HASH_TYPE_SHA1;
10278 salt_type = SALT_TYPE_NONE;
10279 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10280 opts_type = OPTS_TYPE_PT_GENERATE_BE
10281 | OPTS_TYPE_PT_ADD80
10282 | OPTS_TYPE_PT_ADDBITS15;
10283 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10284 dgst_size = DGST_SIZE_4_5;
10285 parse_func = sha1axcrypt_parse_hash;
10286 sort_by_digest = sort_by_digest_4_5;
10287 opti_type = OPTI_TYPE_ZERO_BYTE
10288 | OPTI_TYPE_PRECOMPUTE_INIT
10289 | OPTI_TYPE_EARLY_SKIP
10290 | OPTI_TYPE_NOT_ITERATED
10291 | OPTI_TYPE_NOT_SALTED;
10292 dgst_pos0 = 0;
10293 dgst_pos1 = 4;
10294 dgst_pos2 = 3;
10295 dgst_pos3 = 2;
10296 break;
10297
10298 case 13400: hash_type = HASH_TYPE_AES;
10299 salt_type = SALT_TYPE_EMBEDDED;
10300 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10301 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10302 kern_type = KERN_TYPE_KEEPASS;
10303 dgst_size = DGST_SIZE_4_4;
10304 parse_func = keepass_parse_hash;
10305 sort_by_digest = sort_by_digest_4_4;
10306 opti_type = OPTI_TYPE_ZERO_BYTE;
10307 dgst_pos0 = 0;
10308 dgst_pos1 = 1;
10309 dgst_pos2 = 2;
10310 dgst_pos3 = 3;
10311 break;
10312
10313 case 13500: hash_type = HASH_TYPE_SHA1;
10314 salt_type = SALT_TYPE_EMBEDDED;
10315 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10316 opts_type = OPTS_TYPE_PT_GENERATE_BE
10317 | OPTS_TYPE_PT_UNICODE
10318 | OPTS_TYPE_PT_ADD80;
10319 kern_type = KERN_TYPE_PSTOKEN;
10320 dgst_size = DGST_SIZE_4_5;
10321 parse_func = pstoken_parse_hash;
10322 sort_by_digest = sort_by_digest_4_5;
10323 opti_type = OPTI_TYPE_ZERO_BYTE
10324 | OPTI_TYPE_PRECOMPUTE_INIT
10325 | OPTI_TYPE_EARLY_SKIP
10326 | OPTI_TYPE_NOT_ITERATED
10327 | OPTI_TYPE_PREPENDED_SALT
10328 | OPTI_TYPE_RAW_HASH;
10329 dgst_pos0 = 3;
10330 dgst_pos1 = 4;
10331 dgst_pos2 = 2;
10332 dgst_pos3 = 1;
10333 break;
10334
10335 default: usage_mini_print (PROGNAME); return (-1);
10336 }
10337
10338 /**
10339 * parser
10340 */
10341
10342 data.parse_func = parse_func;
10343
10344 /**
10345 * misc stuff
10346 */
10347
10348 if (hex_salt)
10349 {
10350 if (salt_type == SALT_TYPE_INTERN)
10351 {
10352 opts_type |= OPTS_TYPE_ST_HEX;
10353 }
10354 else
10355 {
10356 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10357
10358 return (-1);
10359 }
10360 }
10361
10362 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10363 | (salt_type == SALT_TYPE_EXTERN)
10364 | (salt_type == SALT_TYPE_EMBEDDED)
10365 | (salt_type == SALT_TYPE_VIRTUAL));
10366
10367 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10368
10369 data.hash_type = hash_type;
10370 data.attack_mode = attack_mode;
10371 data.attack_kern = attack_kern;
10372 data.attack_exec = attack_exec;
10373 data.kern_type = kern_type;
10374 data.opts_type = opts_type;
10375 data.dgst_size = dgst_size;
10376 data.salt_type = salt_type;
10377 data.isSalted = isSalted;
10378 data.sort_by_digest = sort_by_digest;
10379 data.dgst_pos0 = dgst_pos0;
10380 data.dgst_pos1 = dgst_pos1;
10381 data.dgst_pos2 = dgst_pos2;
10382 data.dgst_pos3 = dgst_pos3;
10383
10384 esalt_size = 0;
10385
10386 switch (hash_mode)
10387 {
10388 case 2500: esalt_size = sizeof (wpa_t); break;
10389 case 5300: esalt_size = sizeof (ikepsk_t); break;
10390 case 5400: esalt_size = sizeof (ikepsk_t); break;
10391 case 5500: esalt_size = sizeof (netntlm_t); break;
10392 case 5600: esalt_size = sizeof (netntlm_t); break;
10393 case 6211: esalt_size = sizeof (tc_t); break;
10394 case 6212: esalt_size = sizeof (tc_t); break;
10395 case 6213: esalt_size = sizeof (tc_t); break;
10396 case 6221: esalt_size = sizeof (tc_t); break;
10397 case 6222: esalt_size = sizeof (tc_t); break;
10398 case 6223: esalt_size = sizeof (tc_t); break;
10399 case 6231: esalt_size = sizeof (tc_t); break;
10400 case 6232: esalt_size = sizeof (tc_t); break;
10401 case 6233: esalt_size = sizeof (tc_t); break;
10402 case 6241: esalt_size = sizeof (tc_t); break;
10403 case 6242: esalt_size = sizeof (tc_t); break;
10404 case 6243: esalt_size = sizeof (tc_t); break;
10405 case 6600: esalt_size = sizeof (agilekey_t); break;
10406 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10407 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10408 case 7300: esalt_size = sizeof (rakp_t); break;
10409 case 7500: esalt_size = sizeof (krb5pa_t); break;
10410 case 8200: esalt_size = sizeof (cloudkey_t); break;
10411 case 8800: esalt_size = sizeof (androidfde_t); break;
10412 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10413 case 9400: esalt_size = sizeof (office2007_t); break;
10414 case 9500: esalt_size = sizeof (office2010_t); break;
10415 case 9600: esalt_size = sizeof (office2013_t); break;
10416 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10417 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10418 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10419 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10420 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10421 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10422 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10423 case 10200: esalt_size = sizeof (cram_md5_t); break;
10424 case 10400: esalt_size = sizeof (pdf_t); break;
10425 case 10410: esalt_size = sizeof (pdf_t); break;
10426 case 10420: esalt_size = sizeof (pdf_t); break;
10427 case 10500: esalt_size = sizeof (pdf_t); break;
10428 case 10600: esalt_size = sizeof (pdf_t); break;
10429 case 10700: esalt_size = sizeof (pdf_t); break;
10430 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10431 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10432 case 11400: esalt_size = sizeof (sip_t); break;
10433 case 11600: esalt_size = sizeof (seven_zip_t); break;
10434 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10435 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10436 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10437 case 13000: esalt_size = sizeof (rar5_t); break;
10438 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10439 case 13400: esalt_size = sizeof (keepass_t); break;
10440 case 13500: esalt_size = sizeof (pstoken_t); break;
10441 }
10442
10443 data.esalt_size = esalt_size;
10444
10445 /**
10446 * choose dictionary parser
10447 */
10448
10449 if (hash_type == HASH_TYPE_LM)
10450 {
10451 get_next_word_func = get_next_word_lm;
10452 }
10453 else if (opts_type & OPTS_TYPE_PT_UPPER)
10454 {
10455 get_next_word_func = get_next_word_uc;
10456 }
10457 else
10458 {
10459 get_next_word_func = get_next_word_std;
10460 }
10461
10462 /**
10463 * dictstat
10464 */
10465
10466 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10467
10468 #ifdef _POSIX
10469 size_t dictstat_nmemb = 0;
10470 #endif
10471
10472 #ifdef _WIN
10473 uint dictstat_nmemb = 0;
10474 #endif
10475
10476 char dictstat[256] = { 0 };
10477
10478 FILE *dictstat_fp = NULL;
10479
10480 if (keyspace == 0)
10481 {
10482 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
10483
10484 dictstat_fp = fopen (dictstat, "rb");
10485
10486 if (dictstat_fp)
10487 {
10488 #ifdef _POSIX
10489 struct stat tmpstat;
10490
10491 fstat (fileno (dictstat_fp), &tmpstat);
10492 #endif
10493
10494 #ifdef _WIN
10495 struct stat64 tmpstat;
10496
10497 _fstat64 (fileno (dictstat_fp), &tmpstat);
10498 #endif
10499
10500 if (tmpstat.st_mtime < COMPTIME)
10501 {
10502 /* with v0.15 the format changed so we have to ensure user is using a good version
10503 since there is no version-header in the dictstat file */
10504
10505 fclose (dictstat_fp);
10506
10507 unlink (dictstat);
10508 }
10509 else
10510 {
10511 while (!feof (dictstat_fp))
10512 {
10513 dictstat_t d;
10514
10515 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10516
10517 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10518
10519 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10520 {
10521 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10522
10523 return -1;
10524 }
10525 }
10526
10527 fclose (dictstat_fp);
10528 }
10529 }
10530 }
10531
10532 /**
10533 * potfile
10534 */
10535
10536 char potfile[256] = { 0 };
10537
10538 if (potfile_path == NULL)
10539 {
10540 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
10541 }
10542 else
10543 {
10544 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
10545 }
10546
10547 data.pot_fp = NULL;
10548
10549 FILE *out_fp = NULL;
10550 FILE *pot_fp = NULL;
10551
10552 if (show == 1 || left == 1)
10553 {
10554 pot_fp = fopen (potfile, "rb");
10555
10556 if (pot_fp == NULL)
10557 {
10558 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10559
10560 return (-1);
10561 }
10562
10563 if (outfile != NULL)
10564 {
10565 if ((out_fp = fopen (outfile, "ab")) == NULL)
10566 {
10567 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10568
10569 fclose (pot_fp);
10570
10571 return (-1);
10572 }
10573 }
10574 else
10575 {
10576 out_fp = stdout;
10577 }
10578 }
10579 else
10580 {
10581 if (potfile_disable == 0)
10582 {
10583 pot_fp = fopen (potfile, "ab");
10584
10585 if (pot_fp == NULL)
10586 {
10587 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10588
10589 return (-1);
10590 }
10591
10592 data.pot_fp = pot_fp;
10593 }
10594 }
10595
10596 pot_t *pot = NULL;
10597
10598 uint pot_cnt = 0;
10599 uint pot_avail = 0;
10600
10601 if (show == 1 || left == 1)
10602 {
10603 SUPPRESS_OUTPUT = 1;
10604
10605 pot_avail = count_lines (pot_fp);
10606
10607 rewind (pot_fp);
10608
10609 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10610
10611 uint pot_hashes_avail = 0;
10612
10613 uint line_num = 0;
10614
10615 char *line_buf = (char *) mymalloc (HCBUFSIZ);
10616
10617 while (!feof (pot_fp))
10618 {
10619 line_num++;
10620
10621 int line_len = fgetl (pot_fp, line_buf);
10622
10623 if (line_len == 0) continue;
10624
10625 char *plain_buf = line_buf + line_len;
10626
10627 pot_t *pot_ptr = &pot[pot_cnt];
10628
10629 hash_t *hashes_buf = &pot_ptr->hash;
10630
10631 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10632 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10633
10634 if (pot_cnt == pot_hashes_avail)
10635 {
10636 uint pos = 0;
10637
10638 for (pos = 0; pos < INCR_POT; pos++)
10639 {
10640 if ((pot_cnt + pos) >= pot_avail) break;
10641
10642 pot_t *tmp_pot = &pot[pot_cnt + pos];
10643
10644 hash_t *tmp_hash = &tmp_pot->hash;
10645
10646 tmp_hash->digest = mymalloc (dgst_size);
10647
10648 if (isSalted)
10649 {
10650 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10651 }
10652
10653 if (esalt_size)
10654 {
10655 tmp_hash->esalt = mymalloc (esalt_size);
10656 }
10657
10658 pot_hashes_avail++;
10659 }
10660 }
10661
10662 int plain_len = 0;
10663
10664 int parser_status;
10665
10666 int iter = MAX_CUT_TRIES;
10667
10668 do
10669 {
10670 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10671 {
10672 if (line_buf[i] == ':')
10673 {
10674 line_len--;
10675
10676 break;
10677 }
10678 }
10679
10680 if (data.hash_mode != 2500)
10681 {
10682 parser_status = parse_func (line_buf, line_len, hashes_buf);
10683 }
10684 else
10685 {
10686 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10687
10688 if (line_len > max_salt_size)
10689 {
10690 parser_status = PARSER_GLOBAL_LENGTH;
10691 }
10692 else
10693 {
10694 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10695
10696 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10697
10698 hashes_buf->salt->salt_len = line_len;
10699
10700 parser_status = PARSER_OK;
10701 }
10702 }
10703
10704 // if NOT parsed without error, we add the ":" to the plain
10705
10706 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10707 {
10708 plain_len++;
10709 plain_buf--;
10710 }
10711
10712 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10713
10714 if (parser_status < PARSER_GLOBAL_ZERO)
10715 {
10716 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10717
10718 continue;
10719 }
10720
10721 if (plain_len >= 255) continue;
10722
10723 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10724
10725 pot_ptr->plain_len = plain_len;
10726
10727 pot_cnt++;
10728 }
10729
10730 myfree (line_buf);
10731
10732 fclose (pot_fp);
10733
10734 SUPPRESS_OUTPUT = 0;
10735
10736 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10737 }
10738
10739 /**
10740 * word len
10741 */
10742
10743 uint pw_min = PW_MIN;
10744 uint pw_max = PW_MAX;
10745
10746 switch (hash_mode)
10747 {
10748 case 125: if (pw_max > 32) pw_max = 32;
10749 break;
10750 case 400: if (pw_max > 40) pw_max = 40;
10751 break;
10752 case 500: if (pw_max > 16) pw_max = 16;
10753 break;
10754 case 1500: if (pw_max > 8) pw_max = 8;
10755 break;
10756 case 1600: if (pw_max > 16) pw_max = 16;
10757 break;
10758 case 1800: if (pw_max > 16) pw_max = 16;
10759 break;
10760 case 2100: if (pw_max > 16) pw_max = 16;
10761 break;
10762 case 2500: if (pw_min < 8) pw_min = 8;
10763 break;
10764 case 3000: if (pw_max > 7) pw_max = 7;
10765 break;
10766 case 5200: if (pw_max > 24) pw_max = 24;
10767 break;
10768 case 5800: if (pw_max > 16) pw_max = 16;
10769 break;
10770 case 6300: if (pw_max > 16) pw_max = 16;
10771 break;
10772 case 7400: if (pw_max > 16) pw_max = 16;
10773 break;
10774 case 7900: if (pw_max > 48) pw_max = 48;
10775 break;
10776 case 8500: if (pw_max > 8) pw_max = 8;
10777 break;
10778 case 8600: if (pw_max > 16) pw_max = 16;
10779 break;
10780 case 9710: pw_min = 5;
10781 pw_max = 5;
10782 break;
10783 case 9810: pw_min = 5;
10784 pw_max = 5;
10785 break;
10786 case 10410: pw_min = 5;
10787 pw_max = 5;
10788 break;
10789 case 10300: if (pw_max < 3) pw_min = 3;
10790 if (pw_max > 40) pw_max = 40;
10791 break;
10792 case 10500: if (pw_max < 3) pw_min = 3;
10793 if (pw_max > 40) pw_max = 40;
10794 break;
10795 case 10700: if (pw_max > 16) pw_max = 16;
10796 break;
10797 case 11300: if (pw_max > 40) pw_max = 40;
10798 break;
10799 case 12500: if (pw_max > 20) pw_max = 20;
10800 break;
10801 case 12800: if (pw_max > 24) pw_max = 24;
10802 break;
10803 }
10804
10805 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10806 {
10807 switch (attack_kern)
10808 {
10809 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10810 break;
10811 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10812 break;
10813 }
10814 }
10815
10816 /**
10817 * charsets : keep them together for more easy maintainnce
10818 */
10819
10820 cs_t mp_sys[6] = { { { 0 }, 0 } };
10821 cs_t mp_usr[4] = { { { 0 }, 0 } };
10822
10823 mp_setup_sys (mp_sys);
10824
10825 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10826 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10827 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10828 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10829
10830 /**
10831 * load hashes, part I: find input mode, count hashes
10832 */
10833
10834 uint hashlist_mode = 0;
10835 uint hashlist_format = HLFMT_HASHCAT;
10836
10837 uint hashes_avail = 0;
10838
10839 if (benchmark == 0)
10840 {
10841 struct stat f;
10842
10843 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10844
10845 if ((hash_mode == 2500) ||
10846 (hash_mode == 5200) ||
10847 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10848 (hash_mode == 9000))
10849 {
10850 hashlist_mode = HL_MODE_ARG;
10851
10852 char *hashfile = myargv[optind];
10853
10854 data.hashfile = hashfile;
10855
10856 logfile_top_var_string ("target", hashfile);
10857 }
10858
10859 if (hashlist_mode == HL_MODE_ARG)
10860 {
10861 if (hash_mode == 2500)
10862 {
10863 struct stat st;
10864
10865 if (stat (data.hashfile, &st) == -1)
10866 {
10867 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10868
10869 return (-1);
10870 }
10871
10872 hashes_avail = st.st_size / sizeof (hccap_t);
10873 }
10874 else
10875 {
10876 hashes_avail = 1;
10877 }
10878 }
10879 else if (hashlist_mode == HL_MODE_FILE)
10880 {
10881 char *hashfile = myargv[optind];
10882
10883 data.hashfile = hashfile;
10884
10885 logfile_top_var_string ("target", hashfile);
10886
10887 FILE *fp = NULL;
10888
10889 if ((fp = fopen (hashfile, "rb")) == NULL)
10890 {
10891 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10892
10893 return (-1);
10894 }
10895
10896 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10897
10898 hashes_avail = count_lines (fp);
10899
10900 rewind (fp);
10901
10902 if (hashes_avail == 0)
10903 {
10904 log_error ("ERROR: hashfile is empty or corrupt");
10905
10906 fclose (fp);
10907
10908 return (-1);
10909 }
10910
10911 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10912
10913 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10914 {
10915 log_error ("ERROR: remove not supported in native hashfile-format mode");
10916
10917 fclose (fp);
10918
10919 return (-1);
10920 }
10921
10922 fclose (fp);
10923 }
10924 }
10925 else
10926 {
10927 hashlist_mode = HL_MODE_ARG;
10928
10929 hashes_avail = 1;
10930 }
10931
10932 if (hash_mode == 3000) hashes_avail *= 2;
10933
10934 data.hashlist_mode = hashlist_mode;
10935 data.hashlist_format = hashlist_format;
10936
10937 logfile_top_uint (hashlist_mode);
10938 logfile_top_uint (hashlist_format);
10939
10940 /**
10941 * load hashes, part II: allocate required memory, set pointers
10942 */
10943
10944 hash_t *hashes_buf = NULL;
10945 void *digests_buf = NULL;
10946 salt_t *salts_buf = NULL;
10947 void *esalts_buf = NULL;
10948
10949 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10950
10951 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10952
10953 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10954 {
10955 u32 hash_pos;
10956
10957 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10958 {
10959 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10960
10961 hashes_buf[hash_pos].hash_info = hash_info;
10962
10963 if (username && (remove || show || left))
10964 {
10965 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10966 }
10967
10968 if (benchmark)
10969 {
10970 hash_info->orighash = (char *) mymalloc (256);
10971 }
10972 }
10973 }
10974
10975 if (isSalted)
10976 {
10977 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10978
10979 if (esalt_size)
10980 {
10981 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10982 }
10983 }
10984 else
10985 {
10986 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10987 }
10988
10989 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10990 {
10991 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10992
10993 if (isSalted)
10994 {
10995 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10996
10997 if (esalt_size)
10998 {
10999 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11000 }
11001 }
11002 else
11003 {
11004 hashes_buf[hash_pos].salt = &salts_buf[0];
11005 }
11006 }
11007
11008 /**
11009 * load hashes, part III: parse hashes or generate them if benchmark
11010 */
11011
11012 uint hashes_cnt = 0;
11013
11014 if (benchmark == 0)
11015 {
11016 if (keyspace == 1)
11017 {
11018 // useless to read hash file for keyspace, cheat a little bit w/ optind
11019 }
11020 else if (hashes_avail == 0)
11021 {
11022 }
11023 else if (hashlist_mode == HL_MODE_ARG)
11024 {
11025 char *input_buf = myargv[optind];
11026
11027 uint input_len = strlen (input_buf);
11028
11029 logfile_top_var_string ("target", input_buf);
11030
11031 char *hash_buf = NULL;
11032 int hash_len = 0;
11033
11034 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11035
11036 bool hash_fmt_error = 0;
11037
11038 if (hash_len < 1) hash_fmt_error = 1;
11039 if (hash_buf == NULL) hash_fmt_error = 1;
11040
11041 if (hash_fmt_error)
11042 {
11043 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11044 }
11045 else
11046 {
11047 if (opts_type & OPTS_TYPE_HASH_COPY)
11048 {
11049 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11050
11051 hash_info_tmp->orighash = mystrdup (hash_buf);
11052 }
11053
11054 if (isSalted)
11055 {
11056 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11057 }
11058
11059 int parser_status = PARSER_OK;
11060
11061 if (hash_mode == 2500)
11062 {
11063 if (hash_len == 0)
11064 {
11065 log_error ("ERROR: hccap file not specified");
11066
11067 return (-1);
11068 }
11069
11070 hashlist_mode = HL_MODE_FILE;
11071
11072 data.hashlist_mode = hashlist_mode;
11073
11074 FILE *fp = fopen (hash_buf, "rb");
11075
11076 if (fp == NULL)
11077 {
11078 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11079
11080 return (-1);
11081 }
11082
11083 if (hashes_avail < 1)
11084 {
11085 log_error ("ERROR: hccap file is empty or corrupt");
11086
11087 fclose (fp);
11088
11089 return (-1);
11090 }
11091
11092 uint hccap_size = sizeof (hccap_t);
11093
11094 char *in = (char *) mymalloc (hccap_size);
11095
11096 while (!feof (fp))
11097 {
11098 int n = fread (in, hccap_size, 1, fp);
11099
11100 if (n != 1)
11101 {
11102 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11103
11104 break;
11105 }
11106
11107 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11108
11109 if (parser_status != PARSER_OK)
11110 {
11111 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11112
11113 continue;
11114 }
11115
11116 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11117
11118 if ((show == 1) || (left == 1))
11119 {
11120 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11121
11122 char *salt_ptr = (char *) tmp_salt->salt_buf;
11123
11124 int cur_pos = tmp_salt->salt_len;
11125 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11126
11127 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11128
11129 // do the appending task
11130
11131 snprintf (salt_ptr + cur_pos,
11132 rem_len,
11133 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11134 wpa->orig_mac1[0],
11135 wpa->orig_mac1[1],
11136 wpa->orig_mac1[2],
11137 wpa->orig_mac1[3],
11138 wpa->orig_mac1[4],
11139 wpa->orig_mac1[5],
11140 wpa->orig_mac2[0],
11141 wpa->orig_mac2[1],
11142 wpa->orig_mac2[2],
11143 wpa->orig_mac2[3],
11144 wpa->orig_mac2[4],
11145 wpa->orig_mac2[5]);
11146
11147 // memset () the remaining part of the salt
11148
11149 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11150 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11151
11152 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11153
11154 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11155 }
11156
11157 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);
11158 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);
11159
11160 hashes_cnt++;
11161 }
11162
11163 fclose (fp);
11164
11165 myfree (in);
11166 }
11167 else if (hash_mode == 3000)
11168 {
11169 if (hash_len == 32)
11170 {
11171 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11172
11173 hash_t *lm_hash_left = NULL;
11174
11175 if (parser_status == PARSER_OK)
11176 {
11177 lm_hash_left = &hashes_buf[hashes_cnt];
11178
11179 hashes_cnt++;
11180 }
11181 else
11182 {
11183 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11184 }
11185
11186 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11187
11188 hash_t *lm_hash_right = NULL;
11189
11190 if (parser_status == PARSER_OK)
11191 {
11192 lm_hash_right = &hashes_buf[hashes_cnt];
11193
11194 hashes_cnt++;
11195 }
11196 else
11197 {
11198 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11199 }
11200
11201 // show / left
11202
11203 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11204 {
11205 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);
11206 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);
11207 }
11208 }
11209 else
11210 {
11211 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11212
11213 if (parser_status == PARSER_OK)
11214 {
11215 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11216 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11217 }
11218
11219 if (parser_status == PARSER_OK)
11220 {
11221 hashes_cnt++;
11222 }
11223 else
11224 {
11225 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11226 }
11227 }
11228 }
11229 else
11230 {
11231 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11232
11233 if (parser_status == PARSER_OK)
11234 {
11235 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11236 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11237 }
11238
11239 if (parser_status == PARSER_OK)
11240 {
11241 hashes_cnt++;
11242 }
11243 else
11244 {
11245 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11246 }
11247 }
11248 }
11249 }
11250 else if (hashlist_mode == HL_MODE_FILE)
11251 {
11252 char *hashfile = data.hashfile;
11253
11254 FILE *fp;
11255
11256 if ((fp = fopen (hashfile, "rb")) == NULL)
11257 {
11258 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11259
11260 return (-1);
11261 }
11262
11263 uint line_num = 0;
11264
11265 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11266
11267 while (!feof (fp))
11268 {
11269 line_num++;
11270
11271 int line_len = fgetl (fp, line_buf);
11272
11273 if (line_len == 0) continue;
11274
11275 char *hash_buf = NULL;
11276 int hash_len = 0;
11277
11278 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11279
11280 bool hash_fmt_error = 0;
11281
11282 if (hash_len < 1) hash_fmt_error = 1;
11283 if (hash_buf == NULL) hash_fmt_error = 1;
11284
11285 if (hash_fmt_error)
11286 {
11287 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11288
11289 continue;
11290 }
11291
11292 if (username)
11293 {
11294 char *user_buf = NULL;
11295 int user_len = 0;
11296
11297 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11298
11299 if (remove || show)
11300 {
11301 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11302
11303 *user = (user_t *) mymalloc (sizeof (user_t));
11304
11305 user_t *user_ptr = *user;
11306
11307 if (user_buf != NULL)
11308 {
11309 user_ptr->user_name = mystrdup (user_buf);
11310 }
11311 else
11312 {
11313 user_ptr->user_name = mystrdup ("");
11314 }
11315
11316 user_ptr->user_len = user_len;
11317 }
11318 }
11319
11320 if (opts_type & OPTS_TYPE_HASH_COPY)
11321 {
11322 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11323
11324 hash_info_tmp->orighash = mystrdup (hash_buf);
11325 }
11326
11327 if (isSalted)
11328 {
11329 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11330 }
11331
11332 if (hash_mode == 3000)
11333 {
11334 if (hash_len == 32)
11335 {
11336 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11337
11338 if (parser_status < PARSER_GLOBAL_ZERO)
11339 {
11340 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11341
11342 continue;
11343 }
11344
11345 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11346
11347 hashes_cnt++;
11348
11349 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11350
11351 if (parser_status < PARSER_GLOBAL_ZERO)
11352 {
11353 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11354
11355 continue;
11356 }
11357
11358 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11359
11360 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);
11361
11362 hashes_cnt++;
11363
11364 // show / left
11365
11366 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);
11367 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);
11368 }
11369 else
11370 {
11371 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11372
11373 if (parser_status < PARSER_GLOBAL_ZERO)
11374 {
11375 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11376
11377 continue;
11378 }
11379
11380 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);
11381
11382 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11383 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11384
11385 hashes_cnt++;
11386 }
11387 }
11388 else
11389 {
11390 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11391
11392 if (parser_status < PARSER_GLOBAL_ZERO)
11393 {
11394 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11395
11396 continue;
11397 }
11398
11399 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);
11400
11401 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11402 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11403
11404 hashes_cnt++;
11405 }
11406 }
11407
11408 myfree (line_buf);
11409
11410 fclose (fp);
11411
11412 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11413
11414 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11415 }
11416 }
11417 else
11418 {
11419 if (isSalted)
11420 {
11421 hashes_buf[0].salt->salt_len = 8;
11422
11423 // special salt handling
11424
11425 switch (hash_mode)
11426 {
11427 case 1500: hashes_buf[0].salt->salt_len = 2;
11428 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
11429 break;
11430 case 1731: hashes_buf[0].salt->salt_len = 4;
11431 break;
11432 case 2410: hashes_buf[0].salt->salt_len = 4;
11433 break;
11434 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11435 break;
11436 case 3100: hashes_buf[0].salt->salt_len = 1;
11437 break;
11438 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11439 break;
11440 case 5800: hashes_buf[0].salt->salt_len = 16;
11441 break;
11442 case 6800: hashes_buf[0].salt->salt_len = 32;
11443 break;
11444 case 8400: hashes_buf[0].salt->salt_len = 40;
11445 break;
11446 case 8800: hashes_buf[0].salt->salt_len = 16;
11447 break;
11448 case 8900: hashes_buf[0].salt->salt_len = 16;
11449 hashes_buf[0].salt->scrypt_N = 1024;
11450 hashes_buf[0].salt->scrypt_r = 1;
11451 hashes_buf[0].salt->scrypt_p = 1;
11452 break;
11453 case 9100: hashes_buf[0].salt->salt_len = 16;
11454 break;
11455 case 9300: hashes_buf[0].salt->salt_len = 14;
11456 hashes_buf[0].salt->scrypt_N = 16384;
11457 hashes_buf[0].salt->scrypt_r = 1;
11458 hashes_buf[0].salt->scrypt_p = 1;
11459 break;
11460 case 9400: hashes_buf[0].salt->salt_len = 16;
11461 break;
11462 case 9500: hashes_buf[0].salt->salt_len = 16;
11463 break;
11464 case 9600: hashes_buf[0].salt->salt_len = 16;
11465 break;
11466 case 9700: hashes_buf[0].salt->salt_len = 16;
11467 break;
11468 case 9710: hashes_buf[0].salt->salt_len = 16;
11469 break;
11470 case 9720: hashes_buf[0].salt->salt_len = 16;
11471 break;
11472 case 9800: hashes_buf[0].salt->salt_len = 16;
11473 break;
11474 case 9810: hashes_buf[0].salt->salt_len = 16;
11475 break;
11476 case 9820: hashes_buf[0].salt->salt_len = 16;
11477 break;
11478 case 10300: hashes_buf[0].salt->salt_len = 12;
11479 break;
11480 case 11500: hashes_buf[0].salt->salt_len = 4;
11481 break;
11482 case 11600: hashes_buf[0].salt->salt_len = 4;
11483 break;
11484 case 12400: hashes_buf[0].salt->salt_len = 4;
11485 break;
11486 case 12500: hashes_buf[0].salt->salt_len = 8;
11487 break;
11488 case 12600: hashes_buf[0].salt->salt_len = 64;
11489 break;
11490 }
11491
11492 // special esalt handling
11493
11494 switch (hash_mode)
11495 {
11496 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11497 break;
11498 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11499 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11500 break;
11501 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11502 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11503 break;
11504 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11505 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11506 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11507 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11508 break;
11509 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11510 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11511 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11512 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11513 break;
11514 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11515 break;
11516 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11517 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11518 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11519 break;
11520 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11521 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11522 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11523 break;
11524 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11525 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11526 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11527 break;
11528 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11529 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11530 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11531 break;
11532 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11533 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11534 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11535 break;
11536 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11537 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11538 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11539 break;
11540 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11541 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11542 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11543 break;
11544 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
11545 break;
11546 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
11547 break;
11548 }
11549 }
11550
11551 // set hashfile
11552
11553 switch (hash_mode)
11554 {
11555 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11556 break;
11557 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11558 break;
11559 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11560 break;
11561 case 6211: data.hashfile = mystrdup ("hashcat.tc");
11562 break;
11563 case 6212: data.hashfile = mystrdup ("hashcat.tc");
11564 break;
11565 case 6213: data.hashfile = mystrdup ("hashcat.tc");
11566 break;
11567 case 6221: data.hashfile = mystrdup ("hashcat.tc");
11568 break;
11569 case 6222: data.hashfile = mystrdup ("hashcat.tc");
11570 break;
11571 case 6223: data.hashfile = mystrdup ("hashcat.tc");
11572 break;
11573 case 6231: data.hashfile = mystrdup ("hashcat.tc");
11574 break;
11575 case 6232: data.hashfile = mystrdup ("hashcat.tc");
11576 break;
11577 case 6233: data.hashfile = mystrdup ("hashcat.tc");
11578 break;
11579 case 6241: data.hashfile = mystrdup ("hashcat.tc");
11580 break;
11581 case 6242: data.hashfile = mystrdup ("hashcat.tc");
11582 break;
11583 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11584 break;
11585 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11586 break;
11587 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11588 break;
11589 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11590 break;
11591 }
11592
11593 // set default iterations
11594
11595 switch (hash_mode)
11596 {
11597 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11598 break;
11599 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11600 break;
11601 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11602 break;
11603 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11604 break;
11605 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11606 break;
11607 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11608 break;
11609 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11610 break;
11611 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11612 break;
11613 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11614 break;
11615 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11616 break;
11617 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11618 break;
11619 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11620 break;
11621 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11622 break;
11623 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11624 break;
11625 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11626 break;
11627 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11628 break;
11629 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11630 break;
11631 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11632 break;
11633 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11634 break;
11635 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11636 break;
11637 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11638 break;
11639 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11640 break;
11641 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11642 break;
11643 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11644 break;
11645 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11646 break;
11647 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11648 break;
11649 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11650 break;
11651 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11652 break;
11653 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11654 break;
11655 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11656 break;
11657 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11658 break;
11659 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11660 break;
11661 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11662 break;
11663 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11664 break;
11665 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11666 break;
11667 case 8900: hashes_buf[0].salt->salt_iter = 1;
11668 break;
11669 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11670 break;
11671 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11672 break;
11673 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11674 break;
11675 case 9300: hashes_buf[0].salt->salt_iter = 1;
11676 break;
11677 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11678 break;
11679 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11680 break;
11681 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11682 break;
11683 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11684 break;
11685 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11686 break;
11687 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11688 break;
11689 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11690 break;
11691 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11692 break;
11693 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11694 break;
11695 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11696 break;
11697 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11698 break;
11699 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11700 break;
11701 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11702 break;
11703 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11704 break;
11705 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11706 break;
11707 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11708 break;
11709 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11710 break;
11711 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11712 break;
11713 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11714 break;
11715 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11716 break;
11717 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11718 break;
11719 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
11720 break;
11721 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
11722 break;
11723 }
11724
11725 hashes_cnt = 1;
11726 }
11727
11728 if (show == 1 || left == 1)
11729 {
11730 for (uint i = 0; i < pot_cnt; i++)
11731 {
11732 pot_t *pot_ptr = &pot[i];
11733
11734 hash_t *hashes_buf = &pot_ptr->hash;
11735
11736 local_free (hashes_buf->digest);
11737
11738 if (isSalted)
11739 {
11740 local_free (hashes_buf->salt);
11741 }
11742 }
11743
11744 local_free (pot);
11745
11746 if (data.quiet == 0) log_info_nn ("");
11747
11748 return (0);
11749 }
11750
11751 if (keyspace == 0)
11752 {
11753 if (hashes_cnt == 0)
11754 {
11755 log_error ("ERROR: No hashes loaded");
11756
11757 return (-1);
11758 }
11759 }
11760
11761 /**
11762 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11763 */
11764
11765 if (data.outfile != NULL)
11766 {
11767 if (data.hashfile != NULL)
11768 {
11769 #ifdef _POSIX
11770 struct stat tmpstat_outfile;
11771 struct stat tmpstat_hashfile;
11772 #endif
11773
11774 #ifdef _WIN
11775 struct stat64 tmpstat_outfile;
11776 struct stat64 tmpstat_hashfile;
11777 #endif
11778
11779 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11780
11781 if (tmp_outfile_fp)
11782 {
11783 #ifdef _POSIX
11784 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11785 #endif
11786
11787 #ifdef _WIN
11788 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11789 #endif
11790
11791 fclose (tmp_outfile_fp);
11792 }
11793
11794 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11795
11796 if (tmp_hashfile_fp)
11797 {
11798 #ifdef _POSIX
11799 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11800 #endif
11801
11802 #ifdef _WIN
11803 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11804 #endif
11805
11806 fclose (tmp_hashfile_fp);
11807 }
11808
11809 if (tmp_outfile_fp && tmp_outfile_fp)
11810 {
11811 tmpstat_outfile.st_mode = 0;
11812 tmpstat_outfile.st_nlink = 0;
11813 tmpstat_outfile.st_uid = 0;
11814 tmpstat_outfile.st_gid = 0;
11815 tmpstat_outfile.st_rdev = 0;
11816 tmpstat_outfile.st_atime = 0;
11817
11818 tmpstat_hashfile.st_mode = 0;
11819 tmpstat_hashfile.st_nlink = 0;
11820 tmpstat_hashfile.st_uid = 0;
11821 tmpstat_hashfile.st_gid = 0;
11822 tmpstat_hashfile.st_rdev = 0;
11823 tmpstat_hashfile.st_atime = 0;
11824
11825 #ifdef _POSIX
11826 tmpstat_outfile.st_blksize = 0;
11827 tmpstat_outfile.st_blocks = 0;
11828
11829 tmpstat_hashfile.st_blksize = 0;
11830 tmpstat_hashfile.st_blocks = 0;
11831 #endif
11832
11833 #ifdef _POSIX
11834 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11835 {
11836 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11837
11838 return (-1);
11839 }
11840 #endif
11841
11842 #ifdef _WIN
11843 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11844 {
11845 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11846
11847 return (-1);
11848 }
11849 #endif
11850 }
11851 }
11852 }
11853
11854 /**
11855 * Remove duplicates
11856 */
11857
11858 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11859
11860 if (isSalted)
11861 {
11862 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11863 }
11864 else
11865 {
11866 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11867 }
11868
11869 uint hashes_cnt_orig = hashes_cnt;
11870
11871 hashes_cnt = 1;
11872
11873 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11874 {
11875 if (isSalted)
11876 {
11877 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11878 {
11879 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11880 }
11881 }
11882 else
11883 {
11884 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11885 }
11886
11887 if (hashes_pos > hashes_cnt)
11888 {
11889 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11890 }
11891
11892 hashes_cnt++;
11893 }
11894
11895 /**
11896 * Potfile removes
11897 */
11898
11899 uint potfile_remove_cracks = 0;
11900
11901 if (potfile_disable == 0)
11902 {
11903 hash_t hash_buf;
11904
11905 hash_buf.digest = mymalloc (dgst_size);
11906 hash_buf.salt = NULL;
11907 hash_buf.esalt = NULL;
11908 hash_buf.hash_info = NULL;
11909 hash_buf.cracked = 0;
11910
11911 if (isSalted)
11912 {
11913 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11914 }
11915
11916 if (esalt_size)
11917 {
11918 hash_buf.esalt = mymalloc (esalt_size);
11919 }
11920
11921 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11922
11923 // no solution for these special hash types (for instane because they use hashfile in output etc)
11924 if ((hash_mode != 5200) &&
11925 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11926 (hash_mode != 9000))
11927 {
11928 FILE *fp = fopen (potfile, "rb");
11929
11930 if (fp != NULL)
11931 {
11932 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11933
11934 // to be safe work with a copy (because of line_len loop, i etc)
11935 // moved up here because it's easier to handle continue case
11936 // it's just 64kb
11937
11938 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
11939
11940 while (!feof (fp))
11941 {
11942 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
11943
11944 if (ptr == NULL) break;
11945
11946 int line_len = strlen (line_buf);
11947
11948 if (line_len == 0) continue;
11949
11950 int iter = MAX_CUT_TRIES;
11951
11952 for (int i = line_len - 1; i && iter; i--, line_len--)
11953 {
11954 if (line_buf[i] != ':') continue;
11955
11956 if (isSalted)
11957 {
11958 memset (hash_buf.salt, 0, sizeof (salt_t));
11959 }
11960
11961 hash_t *found = NULL;
11962
11963 if (hash_mode == 6800)
11964 {
11965 if (i < 64) // 64 = 16 * uint in salt_buf[]
11966 {
11967 // manipulate salt_buf
11968 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11969
11970 hash_buf.salt->salt_len = i;
11971
11972 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11973 }
11974 }
11975 else if (hash_mode == 2500)
11976 {
11977 if (i < 64) // 64 = 16 * uint in salt_buf[]
11978 {
11979 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11980 // manipulate salt_buf
11981
11982 memcpy (line_buf_cpy, line_buf, i);
11983
11984 char *mac2_pos = strrchr (line_buf_cpy, ':');
11985
11986 if (mac2_pos == NULL) continue;
11987
11988 mac2_pos[0] = 0;
11989 mac2_pos++;
11990
11991 if (strlen (mac2_pos) != 12) continue;
11992
11993 char *mac1_pos = strrchr (line_buf_cpy, ':');
11994
11995 if (mac1_pos == NULL) continue;
11996
11997 mac1_pos[0] = 0;
11998 mac1_pos++;
11999
12000 if (strlen (mac1_pos) != 12) continue;
12001
12002 uint essid_length = mac1_pos - line_buf_cpy - 1;
12003
12004 // here we need the ESSID
12005 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
12006
12007 hash_buf.salt->salt_len = essid_length;
12008
12009 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
12010
12011 if (found)
12012 {
12013 wpa_t *wpa = (wpa_t *) found->esalt;
12014
12015 // compare hex string(s) vs binary MAC address(es)
12016
12017 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12018 {
12019 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
12020 {
12021 found = NULL;
12022
12023 break;
12024 }
12025 }
12026
12027 // early skip ;)
12028 if (!found) continue;
12029
12030 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12031 {
12032 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
12033 {
12034 found = NULL;
12035
12036 break;
12037 }
12038 }
12039 }
12040 }
12041 }
12042 else
12043 {
12044 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12045
12046 if (parser_status == PARSER_OK)
12047 {
12048 if (isSalted)
12049 {
12050 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12051 }
12052 else
12053 {
12054 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12055 }
12056 }
12057 }
12058
12059 if (found == NULL) continue;
12060
12061 if (!found->cracked) potfile_remove_cracks++;
12062
12063 found->cracked = 1;
12064
12065 if (found) break;
12066
12067 iter--;
12068 }
12069 }
12070
12071 myfree (line_buf_cpy);
12072
12073 myfree (line_buf);
12074
12075 fclose (fp);
12076 }
12077 }
12078
12079 if (esalt_size)
12080 {
12081 local_free (hash_buf.esalt);
12082 }
12083
12084 if (isSalted)
12085 {
12086 local_free (hash_buf.salt);
12087 }
12088
12089 local_free (hash_buf.digest);
12090 }
12091
12092 /**
12093 * Now generate all the buffers required for later
12094 */
12095
12096 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12097
12098 salt_t *salts_buf_new = NULL;
12099 void *esalts_buf_new = NULL;
12100
12101 if (isSalted)
12102 {
12103 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12104
12105 if (esalt_size)
12106 {
12107 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12108 }
12109 }
12110 else
12111 {
12112 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12113 }
12114
12115 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12116
12117 uint digests_cnt = hashes_cnt;
12118 uint digests_done = 0;
12119
12120 uint size_digests = digests_cnt * dgst_size;
12121 uint size_shown = digests_cnt * sizeof (uint);
12122
12123 uint *digests_shown = (uint *) mymalloc (size_shown);
12124 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12125
12126 uint salts_cnt = 0;
12127 uint salts_done = 0;
12128
12129 hashinfo_t **hash_info = NULL;
12130
12131 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12132 {
12133 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12134
12135 if (username && (remove || show))
12136 {
12137 uint user_pos;
12138
12139 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12140 {
12141 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12142
12143 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12144 }
12145 }
12146 }
12147
12148 uint *salts_shown = (uint *) mymalloc (size_shown);
12149
12150 salt_t *salt_buf;
12151
12152 {
12153 // copied from inner loop
12154
12155 salt_buf = &salts_buf_new[salts_cnt];
12156
12157 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12158
12159 if (esalt_size)
12160 {
12161 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12162 }
12163
12164 salt_buf->digests_cnt = 0;
12165 salt_buf->digests_done = 0;
12166 salt_buf->digests_offset = 0;
12167
12168 salts_cnt++;
12169 }
12170
12171 if (hashes_buf[0].cracked == 1)
12172 {
12173 digests_shown[0] = 1;
12174
12175 digests_done++;
12176
12177 salt_buf->digests_done++;
12178 }
12179
12180 salt_buf->digests_cnt++;
12181
12182 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12183
12184 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12185 {
12186 hash_info[0] = hashes_buf[0].hash_info;
12187 }
12188
12189 // copy from inner loop
12190
12191 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12192 {
12193 if (isSalted)
12194 {
12195 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12196 {
12197 salt_buf = &salts_buf_new[salts_cnt];
12198
12199 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12200
12201 if (esalt_size)
12202 {
12203 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12204 }
12205
12206 salt_buf->digests_cnt = 0;
12207 salt_buf->digests_done = 0;
12208 salt_buf->digests_offset = hashes_pos;
12209
12210 salts_cnt++;
12211 }
12212 }
12213
12214 if (hashes_buf[hashes_pos].cracked == 1)
12215 {
12216 digests_shown[hashes_pos] = 1;
12217
12218 digests_done++;
12219
12220 salt_buf->digests_done++;
12221 }
12222
12223 salt_buf->digests_cnt++;
12224
12225 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12226
12227 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12228 {
12229 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12230 }
12231 }
12232
12233 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12234 {
12235 salt_t *salt_buf = &salts_buf_new[salt_pos];
12236
12237 if (salt_buf->digests_done == salt_buf->digests_cnt)
12238 {
12239 salts_shown[salt_pos] = 1;
12240
12241 salts_done++;
12242 }
12243
12244 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12245 }
12246
12247 local_free (digests_buf);
12248 local_free (salts_buf);
12249 local_free (esalts_buf);
12250
12251 digests_buf = digests_buf_new;
12252 salts_buf = salts_buf_new;
12253 esalts_buf = esalts_buf_new;
12254
12255 local_free (hashes_buf);
12256
12257 /**
12258 * special modification not set from parser
12259 */
12260
12261 switch (hash_mode)
12262 {
12263 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12264 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12265 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12266 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12267 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12268 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12269 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12270 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12271 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12272 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12273 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12274 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12275 }
12276
12277 if (truecrypt_keyfiles)
12278 {
12279 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12280
12281 char *keyfiles = strdup (truecrypt_keyfiles);
12282
12283 char *keyfile = strtok (keyfiles, ",");
12284
12285 do
12286 {
12287 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12288
12289 } while ((keyfile = strtok (NULL, ",")) != NULL);
12290
12291 free (keyfiles);
12292 }
12293
12294 data.digests_cnt = digests_cnt;
12295 data.digests_done = digests_done;
12296 data.digests_buf = digests_buf;
12297 data.digests_shown = digests_shown;
12298 data.digests_shown_tmp = digests_shown_tmp;
12299
12300 data.salts_cnt = salts_cnt;
12301 data.salts_done = salts_done;
12302 data.salts_buf = salts_buf;
12303 data.salts_shown = salts_shown;
12304
12305 data.esalts_buf = esalts_buf;
12306 data.hash_info = hash_info;
12307
12308 /**
12309 * Automatic Optimizers
12310 */
12311
12312 if (salts_cnt == 1)
12313 opti_type |= OPTI_TYPE_SINGLE_SALT;
12314
12315 if (digests_cnt == 1)
12316 opti_type |= OPTI_TYPE_SINGLE_HASH;
12317
12318 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12319 opti_type |= OPTI_TYPE_NOT_ITERATED;
12320
12321 if (attack_mode == ATTACK_MODE_BF)
12322 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12323
12324 data.opti_type = opti_type;
12325
12326 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12327 {
12328 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12329 {
12330 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12331 {
12332 if (opts_type & OPTS_TYPE_ST_ADD80)
12333 {
12334 opts_type &= ~OPTS_TYPE_ST_ADD80;
12335 opts_type |= OPTS_TYPE_PT_ADD80;
12336 }
12337
12338 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12339 {
12340 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12341 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12342 }
12343
12344 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12345 {
12346 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12347 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12348 }
12349 }
12350 }
12351 }
12352
12353 /**
12354 * Some algorithm, like descrypt, can benefit from JIT compilation
12355 */
12356
12357 int force_jit_compilation = -1;
12358
12359 if (hash_mode == 8900)
12360 {
12361 force_jit_compilation = 8900;
12362 }
12363 else if (hash_mode == 9300)
12364 {
12365 force_jit_compilation = 8900;
12366 }
12367 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12368 {
12369 force_jit_compilation = 1500;
12370 }
12371
12372 /**
12373 * generate bitmap tables
12374 */
12375
12376 const uint bitmap_shift1 = 5;
12377 const uint bitmap_shift2 = 13;
12378
12379 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12380
12381 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12382 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12383 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12384 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12385 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12386 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12387 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12388 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12389
12390 uint bitmap_bits;
12391 uint bitmap_nums;
12392 uint bitmap_mask;
12393 uint bitmap_size;
12394
12395 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12396 {
12397 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12398
12399 bitmap_nums = 1 << bitmap_bits;
12400
12401 bitmap_mask = bitmap_nums - 1;
12402
12403 bitmap_size = bitmap_nums * sizeof (uint);
12404
12405 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12406
12407 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;
12408 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;
12409
12410 break;
12411 }
12412
12413 bitmap_nums = 1 << bitmap_bits;
12414
12415 bitmap_mask = bitmap_nums - 1;
12416
12417 bitmap_size = bitmap_nums * sizeof (uint);
12418
12419 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);
12420 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);
12421
12422 /**
12423 * prepare quick rule
12424 */
12425
12426 data.rule_buf_l = rule_buf_l;
12427 data.rule_buf_r = rule_buf_r;
12428
12429 int rule_len_l = (int) strlen (rule_buf_l);
12430 int rule_len_r = (int) strlen (rule_buf_r);
12431
12432 data.rule_len_l = rule_len_l;
12433 data.rule_len_r = rule_len_r;
12434
12435 /**
12436 * load rules
12437 */
12438
12439 uint *all_kernel_rules_cnt = NULL;
12440
12441 kernel_rule_t **all_kernel_rules_buf = NULL;
12442
12443 if (rp_files_cnt)
12444 {
12445 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12446
12447 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12448 }
12449
12450 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
12451
12452 int rule_len = 0;
12453
12454 for (uint i = 0; i < rp_files_cnt; i++)
12455 {
12456 uint kernel_rules_avail = 0;
12457
12458 uint kernel_rules_cnt = 0;
12459
12460 kernel_rule_t *kernel_rules_buf = NULL;
12461
12462 char *rp_file = rp_files[i];
12463
12464 char in[BLOCK_SIZE] = { 0 };
12465 char out[BLOCK_SIZE] = { 0 };
12466
12467 FILE *fp = NULL;
12468
12469 uint rule_line = 0;
12470
12471 if ((fp = fopen (rp_file, "rb")) == NULL)
12472 {
12473 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12474
12475 return (-1);
12476 }
12477
12478 while (!feof (fp))
12479 {
12480 memset (rule_buf, 0, HCBUFSIZ);
12481
12482 rule_len = fgetl (fp, rule_buf);
12483
12484 rule_line++;
12485
12486 if (rule_len == 0) continue;
12487
12488 if (rule_buf[0] == '#') continue;
12489
12490 if (kernel_rules_avail == kernel_rules_cnt)
12491 {
12492 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12493
12494 kernel_rules_avail += INCR_RULES;
12495 }
12496
12497 memset (in, 0, BLOCK_SIZE);
12498 memset (out, 0, BLOCK_SIZE);
12499
12500 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12501
12502 if (result == -1)
12503 {
12504 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12505
12506 continue;
12507 }
12508
12509 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12510 {
12511 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12512
12513 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12514
12515 continue;
12516 }
12517
12518 /* its so slow
12519 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12520 {
12521 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12522
12523 continue;
12524 }
12525 */
12526
12527 kernel_rules_cnt++;
12528 }
12529
12530 fclose (fp);
12531
12532 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12533
12534 all_kernel_rules_buf[i] = kernel_rules_buf;
12535 }
12536
12537 /**
12538 * merge rules or automatic rule generator
12539 */
12540
12541 uint kernel_rules_cnt = 0;
12542
12543 kernel_rule_t *kernel_rules_buf = NULL;
12544
12545 if (attack_mode == ATTACK_MODE_STRAIGHT)
12546 {
12547 if (rp_files_cnt)
12548 {
12549 kernel_rules_cnt = 1;
12550
12551 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12552
12553 repeats[0] = kernel_rules_cnt;
12554
12555 for (uint i = 0; i < rp_files_cnt; i++)
12556 {
12557 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12558
12559 repeats[i + 1] = kernel_rules_cnt;
12560 }
12561
12562 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12563
12564 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12565
12566 for (uint i = 0; i < kernel_rules_cnt; i++)
12567 {
12568 uint out_pos = 0;
12569
12570 kernel_rule_t *out = &kernel_rules_buf[i];
12571
12572 for (uint j = 0; j < rp_files_cnt; j++)
12573 {
12574 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12575 uint in_pos;
12576
12577 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12578
12579 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12580 {
12581 if (out_pos == RULES_MAX - 1)
12582 {
12583 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12584
12585 break;
12586 }
12587
12588 out->cmds[out_pos] = in->cmds[in_pos];
12589 }
12590 }
12591 }
12592
12593 local_free (repeats);
12594 }
12595 else if (rp_gen)
12596 {
12597 uint kernel_rules_avail = 0;
12598
12599 while (kernel_rules_cnt < rp_gen)
12600 {
12601 if (kernel_rules_avail == kernel_rules_cnt)
12602 {
12603 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12604
12605 kernel_rules_avail += INCR_RULES;
12606 }
12607
12608 memset (rule_buf, 0, HCBUFSIZ);
12609
12610 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12611
12612 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12613
12614 kernel_rules_cnt++;
12615 }
12616 }
12617 }
12618
12619 myfree (rule_buf);
12620
12621 /**
12622 * generate NOP rules
12623 */
12624
12625 if (kernel_rules_cnt == 0)
12626 {
12627 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12628
12629 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12630
12631 kernel_rules_cnt++;
12632 }
12633
12634 data.kernel_rules_cnt = kernel_rules_cnt;
12635 data.kernel_rules_buf = kernel_rules_buf;
12636
12637 /**
12638 * OpenCL platforms: detect
12639 */
12640
12641 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
12642 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
12643
12644 cl_uint platforms_cnt = 0;
12645 cl_uint platform_devices_cnt = 0;
12646
12647 if (keyspace == 0)
12648 {
12649 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12650
12651 if (platforms_cnt == 0)
12652 {
12653 log_error ("ERROR: No OpenCL compatible platform found");
12654
12655 return (-1);
12656 }
12657
12658 if (opencl_platforms_filter != (uint) -1)
12659 {
12660 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
12661
12662 if (opencl_platforms_filter > platform_cnt_mask)
12663 {
12664 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
12665
12666 return (-1);
12667 }
12668 }
12669 }
12670
12671 /**
12672 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12673 */
12674
12675 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12676 {
12677 cl_platform_id platform = platforms[platform_id];
12678
12679 char platform_vendor[INFOSZ] = { 0 };
12680
12681 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12682
12683 #ifdef HAVE_HWMON
12684 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12685 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12686 {
12687 // make sure that we do not directly control the fan for NVidia
12688
12689 gpu_temp_retain = 0;
12690
12691 data.gpu_temp_retain = gpu_temp_retain;
12692 }
12693 #endif // HAVE_NVML || HAVE_NVAPI
12694 #endif
12695 }
12696
12697 /**
12698 * OpenCL devices: simply push all devices from all platforms into the same device array
12699 */
12700
12701 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12702
12703 data.devices_param = devices_param;
12704
12705 uint devices_cnt = 0;
12706
12707 uint devices_active = 0;
12708
12709 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12710 {
12711 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12712
12713 cl_platform_id platform = platforms[platform_id];
12714
12715 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12716
12717 char platform_vendor[INFOSZ] = { 0 };
12718
12719 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12720
12721 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
12722 // this causes trouble with vendor id based macros
12723 // we'll assign generic to those without special optimization available
12724
12725 cl_uint vendor_id = 0;
12726
12727 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
12728 {
12729 vendor_id = VENDOR_ID_AMD;
12730 }
12731 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
12732 {
12733 vendor_id = VENDOR_ID_GENERIC;
12734 }
12735 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
12736 {
12737 vendor_id = VENDOR_ID_GENERIC;
12738 }
12739 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
12740 {
12741 vendor_id = VENDOR_ID_GENERIC;
12742 }
12743 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
12744 {
12745 vendor_id = VENDOR_ID_GENERIC;
12746 }
12747 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12748 {
12749 vendor_id = VENDOR_ID_NV;
12750 }
12751 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
12752 {
12753 vendor_id = VENDOR_ID_GENERIC;
12754 }
12755 else
12756 {
12757 vendor_id = VENDOR_ID_GENERIC;
12758 }
12759
12760 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12761 {
12762 size_t param_value_size = 0;
12763
12764 const uint device_id = devices_cnt;
12765
12766 hc_device_param_t *device_param = &data.devices_param[device_id];
12767
12768 device_param->vendor_id = vendor_id;
12769
12770 device_param->device = platform_devices[platform_devices_id];
12771
12772 device_param->device_id = device_id;
12773
12774 device_param->platform_devices_id = platform_devices_id;
12775
12776 // device_type
12777
12778 cl_device_type device_type;
12779
12780 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12781
12782 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12783
12784 device_param->device_type = device_type;
12785
12786 // device_name
12787
12788 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
12789
12790 char *device_name = (char *) mymalloc (param_value_size);
12791
12792 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
12793
12794 device_param->device_name = device_name;
12795
12796 // tuning db
12797
12798 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
12799
12800 // device_version
12801
12802 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
12803
12804 char *device_version = (char *) mymalloc (param_value_size);
12805
12806 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
12807
12808 device_param->device_version = device_version;
12809
12810 // device_opencl_version
12811
12812 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
12813
12814 char *device_opencl_version = (char *) mymalloc (param_value_size);
12815
12816 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
12817
12818 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
12819
12820 myfree (device_opencl_version);
12821
12822 // vector_width
12823
12824 cl_uint vector_width;
12825
12826 if (opencl_vector_width_chgd == 0)
12827 {
12828 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
12829 {
12830 if (opti_type & OPTI_TYPE_USES_BITS_64)
12831 {
12832 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
12833 }
12834 else
12835 {
12836 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12837 }
12838 }
12839 else
12840 {
12841 vector_width = (cl_uint) tuningdb_entry->vector_width;
12842 }
12843 }
12844 else
12845 {
12846 vector_width = opencl_vector_width;
12847 }
12848
12849 if (vector_width > 16) vector_width = 16;
12850
12851 device_param->vector_width = vector_width;
12852
12853 // max_compute_units
12854
12855 cl_uint device_processors;
12856
12857 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12858
12859 device_param->device_processors = device_processors;
12860
12861 // max_mem_alloc_size
12862
12863 cl_ulong device_maxmem_alloc;
12864
12865 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12866
12867 device_param->device_maxmem_alloc = device_maxmem_alloc;
12868
12869 // max_mem_alloc_size
12870
12871 cl_ulong device_global_mem;
12872
12873 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12874
12875 device_param->device_global_mem = device_global_mem;
12876
12877 // max_clock_frequency
12878
12879 cl_uint device_maxclock_frequency;
12880
12881 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12882
12883 device_param->device_maxclock_frequency = device_maxclock_frequency;
12884
12885 // skipped
12886
12887 const u32 skipped1 = ((devices_filter & (1 << device_id)) == 0);
12888 const u32 skipped2 = ((device_types_filter & (device_type)) == 0);
12889
12890 device_param->skipped = (skipped1 || skipped2);
12891
12892 // driver_version
12893 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
12894
12895 char *driver_version = (char *) mymalloc (param_value_size);
12896
12897 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
12898
12899 device_param->driver_version = driver_version;
12900
12901 // device_name_chksum
12902
12903 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12904
12905 #if __x86_64__
12906 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);
12907 #else
12908 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);
12909 #endif
12910
12911 uint device_name_digest[4] = { 0 };
12912
12913 md5_64 ((uint *) device_name_chksum, device_name_digest);
12914
12915 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
12916
12917 device_param->device_name_chksum = device_name_chksum;
12918
12919 // device_processor_cores
12920
12921 if (device_type & CL_DEVICE_TYPE_CPU)
12922 {
12923 cl_uint device_processor_cores = 1;
12924
12925 device_param->device_processor_cores = device_processor_cores;
12926 }
12927
12928 if (device_type & CL_DEVICE_TYPE_GPU)
12929 {
12930 if (vendor_id == VENDOR_ID_AMD)
12931 {
12932 cl_uint device_processor_cores = 0;
12933
12934 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12935
12936 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12937
12938 device_param->device_processor_cores = device_processor_cores;
12939 }
12940 else if (vendor_id == VENDOR_ID_NV)
12941 {
12942 cl_uint kernel_exec_timeout = 0;
12943
12944 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12945
12946 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12947
12948 device_param->kernel_exec_timeout = kernel_exec_timeout;
12949
12950 cl_uint device_processor_cores = 0;
12951
12952 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12953
12954 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12955
12956 device_param->device_processor_cores = device_processor_cores;
12957
12958 cl_uint sm_minor = 0;
12959 cl_uint sm_major = 0;
12960
12961 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12962 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12963
12964 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12965 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12966
12967 device_param->sm_minor = sm_minor;
12968 device_param->sm_major = sm_major;
12969 }
12970 else
12971 {
12972 cl_uint device_processor_cores = 1;
12973
12974 device_param->device_processor_cores = device_processor_cores;
12975 }
12976 }
12977
12978 // display results
12979
12980 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12981 {
12982 if (device_param->skipped == 0)
12983 {
12984 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12985 device_id + 1,
12986 device_name,
12987 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
12988 (unsigned int) (device_global_mem / 1024 / 1024),
12989 (unsigned int) (device_maxclock_frequency),
12990 (unsigned int) device_processors);
12991 }
12992 else
12993 {
12994 log_info ("Device #%u: %s, skipped",
12995 device_id + 1,
12996 device_name);
12997 }
12998 }
12999
13000 // common driver check
13001
13002 if (device_param->skipped == 0)
13003 {
13004 if (device_type & CL_DEVICE_TYPE_GPU)
13005 {
13006 if (vendor_id == VENDOR_ID_AMD)
13007 {
13008 int catalyst_check = (force == 1) ? 0 : 1;
13009
13010 int catalyst_warn = 0;
13011
13012 int catalyst_broken = 0;
13013
13014 if (catalyst_check == 1)
13015 {
13016 catalyst_warn = 1;
13017
13018 // v14.9 and higher
13019 if (atoi (device_param->driver_version) >= 1573)
13020 {
13021 catalyst_warn = 0;
13022 }
13023
13024 catalyst_check = 0;
13025 }
13026
13027 if (catalyst_broken == 1)
13028 {
13029 log_info ("");
13030 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
13031 log_info ("It will pass over cracked hashes and does not report them as cracked");
13032 log_info ("You are STRONGLY encouraged not to use it");
13033 log_info ("You can use --force to override this but do not post error reports if you do so");
13034 log_info ("");
13035
13036 return (-1);
13037 }
13038
13039 if (catalyst_warn == 1)
13040 {
13041 log_info ("");
13042 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13043 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13044 log_info ("See oclHashcat's homepage for official supported catalyst drivers");
13045 #ifdef _WIN
13046 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13047 #endif
13048 log_info ("You can use --force to override this but do not post error reports if you do so");
13049 log_info ("");
13050
13051 return (-1);
13052 }
13053 }
13054 else if (vendor_id == VENDOR_ID_NV)
13055 {
13056 if (device_param->kernel_exec_timeout != 0)
13057 {
13058 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);
13059 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
13060 }
13061 }
13062 else if (vendor_id == VENDOR_ID_POCL)
13063 {
13064 if (force == 0)
13065 {
13066 log_info ("");
13067 log_info ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
13068 log_info ("You are STRONGLY encouraged not to use it");
13069 log_info ("You can use --force to override this but do not post error reports if you do so");
13070 log_info ("");
13071
13072 return (-1);
13073 }
13074 }
13075 }
13076
13077 /**
13078 * kernel accel and loops tuning db adjustment
13079 */
13080
13081 device_param->kernel_accel_min = 1;
13082 device_param->kernel_accel_max = 1024;
13083
13084 device_param->kernel_loops_min = 1;
13085 device_param->kernel_loops_max = 1024;
13086
13087 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13088
13089 if (tuningdb_entry)
13090 {
13091 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13092 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13093
13094 if (_kernel_accel)
13095 {
13096 device_param->kernel_accel_min = _kernel_accel;
13097 device_param->kernel_accel_max = _kernel_accel;
13098 }
13099
13100 if (_kernel_loops)
13101 {
13102 if (workload_profile == 1)
13103 {
13104 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13105 }
13106 else if (workload_profile == 2)
13107 {
13108 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13109 }
13110
13111 device_param->kernel_loops_min = _kernel_loops;
13112 device_param->kernel_loops_max = _kernel_loops;
13113 }
13114 }
13115
13116 // commandline parameters overwrite tuningdb entries
13117
13118 if (kernel_accel)
13119 {
13120 device_param->kernel_accel_min = kernel_accel;
13121 device_param->kernel_accel_max = kernel_accel;
13122 }
13123
13124 if (kernel_loops)
13125 {
13126 device_param->kernel_loops_min = kernel_loops;
13127 device_param->kernel_loops_max = kernel_loops;
13128 }
13129
13130 /**
13131 * activate device
13132 */
13133
13134 devices_active++;
13135 }
13136
13137 // next please
13138
13139 devices_cnt++;
13140 }
13141 }
13142
13143 if (keyspace == 0 && devices_active == 0)
13144 {
13145 log_error ("ERROR: No devices found/left");
13146
13147 return (-1);
13148 }
13149
13150 // 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)
13151
13152 if (devices_filter != (uint) -1)
13153 {
13154 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
13155
13156 if (devices_filter > devices_cnt_mask)
13157 {
13158 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
13159
13160 return (-1);
13161 }
13162 }
13163
13164 data.devices_cnt = devices_cnt;
13165
13166 data.devices_active = devices_active;
13167
13168 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13169 {
13170 log_info ("");
13171 }
13172
13173 /**
13174 * HM devices: init
13175 */
13176
13177 #ifdef HAVE_HWMON
13178 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13179 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13180 #endif
13181
13182 #ifdef HAVE_ADL
13183 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13184 #endif
13185
13186 if (gpu_temp_disable == 0)
13187 {
13188 #if defined(WIN) && defined(HAVE_NVAPI)
13189 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13190
13191 if (nvapi_init (nvapi) == 0)
13192 data.hm_nv = nvapi;
13193
13194 if (data.hm_nv)
13195 {
13196 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13197 {
13198 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13199
13200 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13201
13202 int tmp_out = 0;
13203
13204 for (int i = 0; i < tmp_in; i++)
13205 {
13206 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13207 }
13208
13209 for (int i = 0; i < tmp_out; i++)
13210 {
13211 NV_GPU_COOLER_SETTINGS pCoolerSettings;
13212
13213 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
13214
13215 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;
13216 }
13217 }
13218 }
13219 #endif // WIN && HAVE_NVAPI
13220
13221 #if defined(LINUX) && defined(HAVE_NVML)
13222 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13223
13224 if (nvml_init (nvml) == 0)
13225 data.hm_nv = nvml;
13226
13227 if (data.hm_nv)
13228 {
13229 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13230 {
13231 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13232
13233 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13234
13235 int tmp_out = 0;
13236
13237 for (int i = 0; i < tmp_in; i++)
13238 {
13239 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13240 }
13241
13242 for (int i = 0; i < tmp_out; i++)
13243 {
13244 unsigned int speed;
13245
13246 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;
13247 }
13248 }
13249 }
13250 #endif // LINUX && HAVE_NVML
13251
13252 data.hm_amd = NULL;
13253
13254 #ifdef HAVE_ADL
13255 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13256
13257 if (adl_init (adl) == 0)
13258 data.hm_amd = adl;
13259
13260 if (data.hm_amd)
13261 {
13262 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13263 {
13264 // total number of adapters
13265
13266 int hm_adapters_num;
13267
13268 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13269
13270 // adapter info
13271
13272 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13273
13274 if (lpAdapterInfo == NULL) return (-1);
13275
13276 // get a list (of ids of) valid/usable adapters
13277
13278 int num_adl_adapters = 0;
13279
13280 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13281
13282 if (num_adl_adapters > 0)
13283 {
13284 hc_thread_mutex_lock (mux_adl);
13285
13286 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13287
13288 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13289
13290 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13291 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13292
13293 hc_thread_mutex_unlock (mux_adl);
13294 }
13295
13296 myfree (valid_adl_device_list);
13297 myfree (lpAdapterInfo);
13298 }
13299 }
13300 #endif // HAVE_ADL
13301
13302 if (data.hm_amd == NULL && data.hm_nv == NULL)
13303 {
13304 gpu_temp_disable = 1;
13305 }
13306 }
13307
13308 /**
13309 * OpenCL devices: allocate buffer for device specific information
13310 */
13311
13312 #ifdef HAVE_HWMON
13313 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13314
13315 #ifdef HAVE_ADL
13316 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13317
13318 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13319 #endif // ADL
13320 #endif
13321
13322 /**
13323 * enable custom signal handler(s)
13324 */
13325
13326 if (benchmark == 0)
13327 {
13328 hc_signal (sigHandler_default);
13329 }
13330 else
13331 {
13332 hc_signal (sigHandler_benchmark);
13333 }
13334
13335 /**
13336 * User-defined GPU temp handling
13337 */
13338
13339 #ifdef HAVE_HWMON
13340 if (gpu_temp_disable == 1)
13341 {
13342 gpu_temp_abort = 0;
13343 gpu_temp_retain = 0;
13344 }
13345
13346 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13347 {
13348 if (gpu_temp_abort < gpu_temp_retain)
13349 {
13350 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13351
13352 return (-1);
13353 }
13354 }
13355
13356 data.gpu_temp_disable = gpu_temp_disable;
13357 data.gpu_temp_abort = gpu_temp_abort;
13358 data.gpu_temp_retain = gpu_temp_retain;
13359 #endif
13360
13361 /**
13362 * inform the user
13363 */
13364
13365 if (data.quiet == 0)
13366 {
13367 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13368
13369 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);
13370
13371 if (attack_mode == ATTACK_MODE_STRAIGHT)
13372 {
13373 log_info ("Rules: %u", kernel_rules_cnt);
13374 }
13375
13376 if (opti_type)
13377 {
13378 log_info ("Applicable Optimizers:");
13379
13380 for (uint i = 0; i < 32; i++)
13381 {
13382 const uint opti_bit = 1u << i;
13383
13384 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13385 }
13386 }
13387
13388 /**
13389 * Watchdog and Temperature balance
13390 */
13391
13392 #ifdef HAVE_HWMON
13393 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13394 {
13395 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13396 }
13397
13398 if (gpu_temp_abort == 0)
13399 {
13400 log_info ("Watchdog: Temperature abort trigger disabled");
13401 }
13402 else
13403 {
13404 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13405 }
13406
13407 if (gpu_temp_retain == 0)
13408 {
13409 log_info ("Watchdog: Temperature retain trigger disabled");
13410 }
13411 else
13412 {
13413 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13414 }
13415 #endif
13416 }
13417
13418 if (data.quiet == 0) log_info ("");
13419
13420 /**
13421 * HM devices: copy
13422 */
13423
13424 if (gpu_temp_disable == 0)
13425 {
13426 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13427 {
13428 hc_device_param_t *device_param = &data.devices_param[device_id];
13429
13430 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13431
13432 if (device_param->skipped) continue;
13433
13434 const uint platform_devices_id = device_param->platform_devices_id;
13435
13436 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13437 if (device_param->vendor_id == VENDOR_ID_NV)
13438 {
13439 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13440 }
13441 #endif
13442
13443 #ifdef HAVE_ADL
13444 if (device_param->vendor_id == VENDOR_ID_AMD)
13445 {
13446 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13447 }
13448 #endif
13449 }
13450 }
13451
13452 /*
13453 * Temporary fix:
13454 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13455 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13456 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13457 * Driver / ADL bug?
13458 */
13459
13460 #ifdef HAVE_ADL
13461 if (powertune_enable == 1)
13462 {
13463 hc_thread_mutex_lock (mux_adl);
13464
13465 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13466 {
13467 hc_device_param_t *device_param = &data.devices_param[device_id];
13468
13469 if (device_param->skipped) continue;
13470
13471 if (data.hm_device[device_id].od_version == 6)
13472 {
13473 // set powertune value only
13474
13475 int powertune_supported = 0;
13476
13477 int ADL_rc = 0;
13478
13479 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13480 {
13481 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13482
13483 return (-1);
13484 }
13485
13486 if (powertune_supported != 0)
13487 {
13488 // powertune set
13489 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13490
13491 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13492 {
13493 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13494
13495 return (-1);
13496 }
13497
13498 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13499 {
13500 log_error ("ERROR: Failed to set new ADL PowerControl values");
13501
13502 return (-1);
13503 }
13504 }
13505 }
13506 }
13507
13508 hc_thread_mutex_unlock (mux_adl);
13509 }
13510 #endif // HAVE_ADK
13511 #endif // HAVE_HWMON
13512
13513 #ifdef DEBUG
13514 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
13515 #endif
13516
13517 uint kernel_power_all = 0;
13518
13519 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13520 {
13521 /**
13522 * host buffer
13523 */
13524
13525 hc_device_param_t *device_param = &data.devices_param[device_id];
13526
13527 if (device_param->skipped) continue;
13528
13529 /**
13530 * device properties
13531 */
13532
13533 const char *device_name_chksum = device_param->device_name_chksum;
13534 const u32 device_processors = device_param->device_processors;
13535 const u32 device_processor_cores = device_param->device_processor_cores;
13536
13537 /**
13538 * create context for each device
13539 */
13540
13541 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
13542
13543 /**
13544 * create command-queue
13545 */
13546
13547 // not supported with NV
13548 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13549
13550 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
13551
13552 /**
13553 * create input buffers on device : calculate size of fixed memory buffers
13554 */
13555
13556 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13557 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13558
13559 device_param->size_root_css = size_root_css;
13560 device_param->size_markov_css = size_markov_css;
13561
13562 uint size_results = KERNEL_THREADS * sizeof (uint);
13563
13564 device_param->size_results = size_results;
13565
13566 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13567 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13568
13569 uint size_plains = digests_cnt * sizeof (plain_t);
13570 uint size_salts = salts_cnt * sizeof (salt_t);
13571 uint size_esalts = salts_cnt * esalt_size;
13572
13573 device_param->size_plains = size_plains;
13574 device_param->size_digests = size_digests;
13575 device_param->size_shown = size_shown;
13576 device_param->size_salts = size_salts;
13577
13578 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13579 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13580 uint size_tm = 32 * sizeof (bs_word_t);
13581
13582 // scryptV stuff
13583
13584 u64 size_scryptV = 1;
13585
13586 if ((hash_mode == 8900) || (hash_mode == 9300))
13587 {
13588 uint tmto_start = 0;
13589 uint tmto_stop = 10;
13590
13591 if (scrypt_tmto)
13592 {
13593 tmto_start = scrypt_tmto;
13594 }
13595 else
13596 {
13597 // in case the user did not specify the tmto manually
13598 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13599 // but set the lower end only in case the user has a device with too less memory
13600
13601 if (hash_mode == 8900)
13602 {
13603 if (device_param->vendor_id == VENDOR_ID_AMD)
13604 {
13605 tmto_start = 1;
13606 }
13607 else if (device_param->vendor_id == VENDOR_ID_NV)
13608 {
13609 tmto_start = 3;
13610 }
13611 }
13612 else if (hash_mode == 9300)
13613 {
13614 if (device_param->vendor_id == VENDOR_ID_AMD)
13615 {
13616 tmto_start = 3;
13617 }
13618 else if (device_param->vendor_id == VENDOR_ID_NV)
13619 {
13620 tmto_start = 5;
13621 }
13622 }
13623 }
13624
13625 if (quiet == 0) log_info ("");
13626
13627 uint shader_per_mp = 1;
13628
13629 if (device_param->vendor_id == VENDOR_ID_AMD)
13630 {
13631 shader_per_mp = 8;
13632 }
13633 else if (device_param->vendor_id == VENDOR_ID_NV)
13634 {
13635 shader_per_mp = 32;
13636 }
13637
13638 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13639 {
13640 // TODO: in theory the following calculation needs to be done per salt, not global
13641 // we assume all hashes have the same scrypt settings
13642
13643 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13644
13645 size_scryptV /= 1 << tmto;
13646
13647 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13648
13649 if (size_scryptV > device_param->device_maxmem_alloc)
13650 {
13651 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13652
13653 continue;
13654 }
13655
13656 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13657 {
13658 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13659 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13660 }
13661
13662 break;
13663 }
13664
13665 if (data.salts_buf[0].scrypt_phy == 0)
13666 {
13667 log_error ("ERROR: can't allocate enough device memory");
13668
13669 return -1;
13670 }
13671
13672 if (quiet == 0) log_info ("");
13673 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13674 }
13675
13676 /**
13677 * create input buffers on device : calculate size of dynamic size memory buffers
13678 */
13679
13680 uint kernel_threads = KERNEL_THREADS;
13681
13682 // some algorithms need a fixed kernel-threads count (mostly because of shared memory usage)
13683
13684 if (hash_mode == 3200) kernel_threads = 8;
13685 if (hash_mode == 9000) kernel_threads = 8;
13686
13687 /**
13688 * some algorithms need a fixed kernel-loops count
13689 */
13690
13691 if (hash_mode == 1500)
13692 {
13693 const u32 kernel_loops_fixed = 1024;
13694
13695 device_param->kernel_loops_min = kernel_loops_fixed;
13696 device_param->kernel_loops_max = kernel_loops_fixed;
13697 }
13698
13699 if (hash_mode == 3000)
13700 {
13701 const u32 kernel_loops_fixed = 1024;
13702
13703 device_param->kernel_loops_min = kernel_loops_fixed;
13704 device_param->kernel_loops_max = kernel_loops_fixed;
13705 }
13706
13707 if (hash_mode == 8900)
13708 {
13709 const u32 kernel_loops_fixed = 1;
13710
13711 device_param->kernel_loops_min = kernel_loops_fixed;
13712 device_param->kernel_loops_max = kernel_loops_fixed;
13713 }
13714
13715 if (hash_mode == 9300)
13716 {
13717 const u32 kernel_loops_fixed = 1;
13718
13719 device_param->kernel_loops_min = kernel_loops_fixed;
13720 device_param->kernel_loops_max = kernel_loops_fixed;
13721 }
13722
13723 if (hash_mode == 12500)
13724 {
13725 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
13726
13727 device_param->kernel_loops_min = kernel_loops_fixed;
13728 device_param->kernel_loops_max = kernel_loops_fixed;
13729 }
13730
13731 /**
13732 * some algorithms have a maximum kernel-loops count
13733 */
13734
13735 if (attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
13736 {
13737 if (data.salts_buf[0].salt_iter < device_param->kernel_loops_max)
13738 {
13739 device_param->kernel_loops_max = data.salts_buf[0].salt_iter;
13740 }
13741 }
13742
13743 /**
13744 * some algorithms need a special kernel-accel
13745 */
13746
13747 if (hash_mode == 8900)
13748 {
13749 device_param->kernel_accel_min = 1;
13750 device_param->kernel_accel_max = 64;
13751 }
13752
13753 if (hash_mode == 9300)
13754 {
13755 device_param->kernel_accel_min = 1;
13756 device_param->kernel_accel_max = 64;
13757 }
13758
13759 u32 kernel_accel_min = device_param->kernel_accel_min;
13760 u32 kernel_accel_max = device_param->kernel_accel_max;
13761
13762 // find out if we would request too much memory on memory blocks which are based on kernel_accel
13763
13764 uint size_pws = 4;
13765 uint size_tmps = 4;
13766 uint size_hooks = 4;
13767
13768 while (kernel_accel_max >= kernel_accel_min)
13769 {
13770 uint kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
13771
13772 // size_pws
13773
13774 size_pws = kernel_power_max * sizeof (pw_t);
13775
13776 // size_tmps
13777
13778 switch (hash_mode)
13779 {
13780 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
13781 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13782 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13783 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13784 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
13785 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
13786 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
13787 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
13788 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
13789 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
13790 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13791 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13792 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13793 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13794 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13795 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13796 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13797 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13798 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13799 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13800 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13801 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13802 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13803 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
13804 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
13805 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
13806 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
13807 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
13808 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13809 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13810 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
13811 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
13812 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13813 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
13814 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13815 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
13816 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
13817 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13818 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13819 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
13820 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
13821 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
13822 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13823 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
13824 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
13825 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
13826 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
13827 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13828 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
13829 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
13830 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
13831 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
13832 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13833 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
13834 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
13835 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
13836 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
13837 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
13838 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13839 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13840 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13841 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
13842 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
13843 };
13844
13845 // size_hooks
13846
13847 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13848 {
13849 // none yet
13850 }
13851
13852 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
13853 // if not, decrease amplifier and try again
13854
13855 int skip = 0;
13856
13857 if (size_pws > device_param->device_maxmem_alloc) skip = 1;
13858 if (size_tmps > device_param->device_maxmem_alloc) skip = 1;
13859 if (size_hooks > device_param->device_maxmem_alloc) skip = 1;
13860
13861 if (( bitmap_size
13862 + bitmap_size
13863 + bitmap_size
13864 + bitmap_size
13865 + bitmap_size
13866 + bitmap_size
13867 + bitmap_size
13868 + bitmap_size
13869 + size_bfs
13870 + size_combs
13871 + size_digests
13872 + size_esalts
13873 + size_hooks
13874 + size_markov_css
13875 + size_plains
13876 + size_pws
13877 + size_results
13878 + size_root_css
13879 + size_rules
13880 + size_rules_c
13881 + size_salts
13882 + size_scryptV
13883 + size_shown
13884 + size_tm
13885 + size_tmps) > device_param->device_global_mem) skip = 1;
13886
13887 if (skip == 1)
13888 {
13889 kernel_accel_max--;
13890
13891 continue;
13892 }
13893
13894 break;
13895 }
13896
13897 /*
13898 if (kernel_accel_max == 0)
13899 {
13900 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
13901
13902 return -1;
13903 }
13904 */
13905
13906 device_param->kernel_accel_min = kernel_accel_min;
13907 device_param->kernel_accel_max = kernel_accel_max;
13908
13909 /*
13910 if (kernel_accel_max < kernel_accel)
13911 {
13912 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
13913
13914 device_param->kernel_accel = kernel_accel_max;
13915 }
13916 */
13917
13918 device_param->size_bfs = size_bfs;
13919 device_param->size_combs = size_combs;
13920 device_param->size_rules = size_rules;
13921 device_param->size_rules_c = size_rules_c;
13922 device_param->size_pws = size_pws;
13923 device_param->size_tmps = size_tmps;
13924 device_param->size_hooks = size_hooks;
13925
13926 // do not confuse kernel_accel_max with kernel_accel here
13927
13928 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
13929
13930 device_param->kernel_threads = kernel_threads;
13931 device_param->kernel_power_user = kernel_power;
13932
13933 kernel_power_all += kernel_power;
13934
13935 /**
13936 * default building options
13937 */
13938
13939 char build_opts[1024] = { 0 };
13940
13941 // we don't have sm_* on vendors not NV but it doesn't matter
13942
13943 snprintf (build_opts, sizeof (build_opts) - 1, "-I\"%s/\" -DVENDOR_ID=%u -DCUDA_ARCH=%d -DVECT_SIZE=%u -DDEVICE_TYPE=%u", shared_dir, device_param->vendor_id, (device_param->sm_major * 100) + device_param->sm_minor, device_param->vector_width, (u32) device_param->device_type);
13944
13945 /**
13946 * main kernel
13947 */
13948
13949 {
13950 /**
13951 * kernel source filename
13952 */
13953
13954 char source_file[256] = { 0 };
13955
13956 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13957
13958 struct stat sst;
13959
13960 if (stat (source_file, &sst) == -1)
13961 {
13962 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13963
13964 return -1;
13965 }
13966
13967 /**
13968 * kernel cached filename
13969 */
13970
13971 char cached_file[256] = { 0 };
13972
13973 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
13974
13975 int cached = 1;
13976
13977 struct stat cst;
13978
13979 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
13980 {
13981 cached = 0;
13982 }
13983
13984 /**
13985 * kernel compile or load
13986 */
13987
13988 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13989
13990 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13991
13992 if (force_jit_compilation == -1)
13993 {
13994 if (cached == 0)
13995 {
13996 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13997
13998 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13999
14000 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14001
14002 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
14003
14004 #ifdef DEBUG
14005 size_t build_log_size = 0;
14006
14007 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14008
14009 if (build_log_size > 1)
14010 {
14011 char *build_log = (char *) malloc (build_log_size + 1);
14012
14013 memset (build_log, 0, build_log_size + 1);
14014
14015 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14016
14017 puts (build_log);
14018
14019 free (build_log);
14020 }
14021 #endif
14022
14023 if (rc != 0)
14024 {
14025 device_param->skipped = true;
14026 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14027 continue;
14028 }
14029
14030 size_t binary_size;
14031
14032 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14033
14034 u8 *binary = (u8 *) mymalloc (binary_size);
14035
14036 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14037
14038 writeProgramBin (cached_file, binary, binary_size);
14039
14040 local_free (binary);
14041 }
14042 else
14043 {
14044 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14045
14046 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14047
14048 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14049
14050 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
14051 }
14052 }
14053 else
14054 {
14055 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
14056
14057 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14058
14059 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14060
14061 char build_opts_update[1024] = { 0 };
14062
14063 if (force_jit_compilation == 1500)
14064 {
14065 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
14066 }
14067 else if (force_jit_compilation == 8900)
14068 {
14069 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);
14070 }
14071 else
14072 {
14073 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
14074 }
14075
14076 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
14077
14078 #ifdef DEBUG
14079 size_t build_log_size = 0;
14080
14081 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14082
14083 if (build_log_size > 1)
14084 {
14085 char *build_log = (char *) malloc (build_log_size + 1);
14086
14087 memset (build_log, 0, build_log_size + 1);
14088
14089 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14090
14091 puts (build_log);
14092
14093 free (build_log);
14094 }
14095 #endif
14096
14097 if (rc != 0)
14098 {
14099 device_param->skipped = true;
14100
14101 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14102 }
14103 }
14104
14105 local_free (kernel_lengths);
14106 local_free (kernel_sources[0]);
14107 local_free (kernel_sources);
14108 }
14109
14110 /**
14111 * word generator kernel
14112 */
14113
14114 if (attack_mode != ATTACK_MODE_STRAIGHT)
14115 {
14116 /**
14117 * kernel mp source filename
14118 */
14119
14120 char source_file[256] = { 0 };
14121
14122 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
14123
14124 struct stat sst;
14125
14126 if (stat (source_file, &sst) == -1)
14127 {
14128 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14129
14130 return -1;
14131 }
14132
14133 /**
14134 * kernel mp cached filename
14135 */
14136
14137 char cached_file[256] = { 0 };
14138
14139 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
14140
14141 int cached = 1;
14142
14143 struct stat cst;
14144
14145 if (stat (cached_file, &cst) == -1)
14146 {
14147 cached = 0;
14148 }
14149
14150 /**
14151 * kernel compile or load
14152 */
14153
14154 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14155
14156 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14157
14158 if (cached == 0)
14159 {
14160 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14161
14162 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14163
14164 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14165
14166 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
14167
14168 if (rc != 0)
14169 {
14170 device_param->skipped = true;
14171 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14172 continue;
14173 }
14174
14175 size_t binary_size;
14176
14177 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14178
14179 u8 *binary = (u8 *) mymalloc (binary_size);
14180
14181 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14182
14183 writeProgramBin (cached_file, binary, binary_size);
14184
14185 local_free (binary);
14186 }
14187 else
14188 {
14189 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14190
14191 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14192
14193 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14194
14195 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
14196 }
14197
14198 local_free (kernel_lengths);
14199 local_free (kernel_sources[0]);
14200 local_free (kernel_sources);
14201 }
14202
14203 /**
14204 * amplifier kernel
14205 */
14206
14207 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14208 {
14209
14210 }
14211 else
14212 {
14213 /**
14214 * kernel amp source filename
14215 */
14216
14217 char source_file[256] = { 0 };
14218
14219 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
14220
14221 struct stat sst;
14222
14223 if (stat (source_file, &sst) == -1)
14224 {
14225 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14226
14227 return -1;
14228 }
14229
14230 /**
14231 * kernel amp cached filename
14232 */
14233
14234 char cached_file[256] = { 0 };
14235
14236 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
14237
14238 int cached = 1;
14239
14240 struct stat cst;
14241
14242 if (stat (cached_file, &cst) == -1)
14243 {
14244 cached = 0;
14245 }
14246
14247 /**
14248 * kernel compile or load
14249 */
14250
14251 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14252
14253 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14254
14255 if (cached == 0)
14256 {
14257 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14258
14259 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14260
14261 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14262
14263 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
14264
14265 if (rc != 0)
14266 {
14267 device_param->skipped = true;
14268 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14269 continue;
14270 }
14271
14272 size_t binary_size;
14273
14274 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14275
14276 u8 *binary = (u8 *) mymalloc (binary_size);
14277
14278 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14279
14280 writeProgramBin (cached_file, binary, binary_size);
14281
14282 local_free (binary);
14283 }
14284 else
14285 {
14286 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14287
14288 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14289
14290 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14291
14292 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
14293 }
14294
14295 local_free (kernel_lengths);
14296 local_free (kernel_sources[0]);
14297 local_free (kernel_sources);
14298 }
14299
14300 // some algorithm collide too fast, make that impossible
14301
14302 if (benchmark == 1)
14303 {
14304 ((uint *) digests_buf)[0] = -1;
14305 ((uint *) digests_buf)[1] = -1;
14306 ((uint *) digests_buf)[2] = -1;
14307 ((uint *) digests_buf)[3] = -1;
14308 }
14309
14310 /**
14311 * global buffers
14312 */
14313
14314 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14315 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14316 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
14317 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
14318 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14319 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14320 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14321 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14322 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14323 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14324 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14325 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14326 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
14327 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
14328 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
14329 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
14330 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
14331 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
14332
14333 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);
14334 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);
14335 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);
14336 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);
14337 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);
14338 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);
14339 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);
14340 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);
14341 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
14342 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
14343 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
14344
14345 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
14346 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
14347 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
14348 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
14349 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
14350 run_kernel_bzero (device_param, device_param->d_result, size_results);
14351
14352 /**
14353 * special buffers
14354 */
14355
14356 if (attack_kern == ATTACK_KERN_STRAIGHT)
14357 {
14358 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
14359 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
14360
14361 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
14362
14363 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
14364 }
14365 else if (attack_kern == ATTACK_KERN_COMBI)
14366 {
14367 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14368 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14369 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14370 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14371
14372 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
14373 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
14374 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14375 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14376 }
14377 else if (attack_kern == ATTACK_KERN_BF)
14378 {
14379 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14380 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14381 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
14382 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14383 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14384
14385 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
14386 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
14387 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
14388 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14389 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14390 }
14391
14392 if (size_esalts)
14393 {
14394 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
14395
14396 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
14397 }
14398
14399 /**
14400 * main host data
14401 */
14402
14403 uint *result = (uint *) mymalloc (size_results);
14404
14405 device_param->result = result;
14406
14407 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
14408
14409 device_param->pws_buf = pws_buf;
14410
14411 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
14412
14413 device_param->combs_buf = combs_buf;
14414
14415 void *hooks_buf = mymalloc (size_hooks);
14416
14417 device_param->hooks_buf = hooks_buf;
14418
14419 /**
14420 * kernel args
14421 */
14422
14423 device_param->kernel_params_buf32[21] = bitmap_mask;
14424 device_param->kernel_params_buf32[22] = bitmap_shift1;
14425 device_param->kernel_params_buf32[23] = bitmap_shift2;
14426 device_param->kernel_params_buf32[24] = 0; // salt_pos
14427 device_param->kernel_params_buf32[25] = 0; // loop_pos
14428 device_param->kernel_params_buf32[26] = 0; // loop_cnt
14429 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
14430 device_param->kernel_params_buf32[28] = 0; // digests_cnt
14431 device_param->kernel_params_buf32[29] = 0; // digests_offset
14432 device_param->kernel_params_buf32[30] = 0; // combs_mode
14433 device_param->kernel_params_buf32[31] = 0; // gid_max
14434
14435 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14436 ? &device_param->d_pws_buf
14437 : &device_param->d_pws_amp_buf;
14438 device_param->kernel_params[ 1] = &device_param->d_rules_c;
14439 device_param->kernel_params[ 2] = &device_param->d_combs_c;
14440 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
14441 device_param->kernel_params[ 4] = &device_param->d_tmps;
14442 device_param->kernel_params[ 5] = &device_param->d_hooks;
14443 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
14444 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
14445 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
14446 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
14447 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
14448 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
14449 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
14450 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
14451 device_param->kernel_params[14] = &device_param->d_plain_bufs;
14452 device_param->kernel_params[15] = &device_param->d_digests_buf;
14453 device_param->kernel_params[16] = &device_param->d_digests_shown;
14454 device_param->kernel_params[17] = &device_param->d_salt_bufs;
14455 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
14456 device_param->kernel_params[19] = &device_param->d_result;
14457 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
14458 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
14459 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
14460 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
14461 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
14462 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
14463 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
14464 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
14465 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
14466 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
14467 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
14468 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
14469
14470 device_param->kernel_params_mp_buf64[3] = 0;
14471 device_param->kernel_params_mp_buf32[4] = 0;
14472 device_param->kernel_params_mp_buf32[5] = 0;
14473 device_param->kernel_params_mp_buf32[6] = 0;
14474 device_param->kernel_params_mp_buf32[7] = 0;
14475 device_param->kernel_params_mp_buf32[8] = 0;
14476
14477 device_param->kernel_params_mp[0] = NULL;
14478 device_param->kernel_params_mp[1] = NULL;
14479 device_param->kernel_params_mp[2] = NULL;
14480 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
14481 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
14482 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
14483 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
14484 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
14485 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
14486
14487 device_param->kernel_params_mp_l_buf64[3] = 0;
14488 device_param->kernel_params_mp_l_buf32[4] = 0;
14489 device_param->kernel_params_mp_l_buf32[5] = 0;
14490 device_param->kernel_params_mp_l_buf32[6] = 0;
14491 device_param->kernel_params_mp_l_buf32[7] = 0;
14492 device_param->kernel_params_mp_l_buf32[8] = 0;
14493 device_param->kernel_params_mp_l_buf32[9] = 0;
14494
14495 device_param->kernel_params_mp_l[0] = NULL;
14496 device_param->kernel_params_mp_l[1] = NULL;
14497 device_param->kernel_params_mp_l[2] = NULL;
14498 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14499 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14500 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14501 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14502 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14503 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14504 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14505
14506 device_param->kernel_params_mp_r_buf64[3] = 0;
14507 device_param->kernel_params_mp_r_buf32[4] = 0;
14508 device_param->kernel_params_mp_r_buf32[5] = 0;
14509 device_param->kernel_params_mp_r_buf32[6] = 0;
14510 device_param->kernel_params_mp_r_buf32[7] = 0;
14511 device_param->kernel_params_mp_r_buf32[8] = 0;
14512
14513 device_param->kernel_params_mp_r[0] = NULL;
14514 device_param->kernel_params_mp_r[1] = NULL;
14515 device_param->kernel_params_mp_r[2] = NULL;
14516 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14517 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14518 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14519 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14520 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14521 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14522
14523 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14524 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14525
14526 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14527 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14528 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14529 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14530 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14531 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14532 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14533
14534 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14535 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14536
14537 /**
14538 * kernel name
14539 */
14540
14541 char kernel_name[64] = { 0 };
14542
14543 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14544 {
14545 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14546 {
14547 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14548
14549 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14550
14551 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14552
14553 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14554
14555 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14556
14557 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14558 }
14559 else
14560 {
14561 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14562
14563 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14564
14565 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14566
14567 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14568
14569 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14570
14571 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14572 }
14573
14574 if (data.attack_mode == ATTACK_MODE_BF)
14575 {
14576 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14577 {
14578 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14579
14580 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14581 }
14582 }
14583 }
14584 else
14585 {
14586 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14587
14588 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14589
14590 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14591
14592 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14593
14594 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14595
14596 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14597
14598 if (opts_type & OPTS_TYPE_HOOK12)
14599 {
14600 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14601
14602 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14603 }
14604
14605 if (opts_type & OPTS_TYPE_HOOK23)
14606 {
14607 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14608
14609 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14610 }
14611 }
14612
14613 for (uint i = 0; i <= 20; i++)
14614 {
14615 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14616 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14617 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14618
14619 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14620 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14621 }
14622
14623 for (uint i = 21; i <= 31; i++)
14624 {
14625 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14626 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14627 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14628
14629 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14630 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14631 }
14632
14633 if (attack_mode == ATTACK_MODE_BF)
14634 {
14635 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
14636 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
14637
14638 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14639 {
14640 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14641 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14642 }
14643 }
14644 else if (attack_mode == ATTACK_MODE_HYBRID1)
14645 {
14646 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14647 }
14648 else if (attack_mode == ATTACK_MODE_HYBRID2)
14649 {
14650 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14651 }
14652
14653 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14654 {
14655 // nothing to do
14656 }
14657 else
14658 {
14659 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
14660 }
14661
14662 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14663 {
14664 // nothing to do
14665 }
14666 else
14667 {
14668 for (uint i = 0; i < 5; i++)
14669 {
14670 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14671 }
14672
14673 for (uint i = 5; i < 7; i++)
14674 {
14675 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14676 }
14677 }
14678
14679 /**
14680 * Store initial fanspeed if gpu_temp_retain is enabled
14681 */
14682
14683 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
14684 int gpu_temp_retain_set = 0;
14685
14686 if (gpu_temp_disable == 0)
14687 {
14688 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14689 {
14690 hc_thread_mutex_lock (mux_adl);
14691
14692 if (data.hm_device[device_id].fan_supported == 1)
14693 {
14694 if (gpu_temp_retain_chgd == 0)
14695 {
14696 uint cur_temp = 0;
14697 uint default_temp = 0;
14698
14699 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);
14700
14701 if (ADL_rc == ADL_OK)
14702 {
14703 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14704
14705 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14706
14707 // special case with multi gpu setups: always use minimum retain
14708
14709 if (gpu_temp_retain_set == 0)
14710 {
14711 gpu_temp_retain = gpu_temp_retain_target;
14712 gpu_temp_retain_set = 1;
14713 }
14714 else
14715 {
14716 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14717 }
14718
14719 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14720 }
14721 }
14722
14723 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14724
14725 temp_retain_fanspeed_value[device_id] = fan_speed;
14726
14727 if (fan_speed == -1)
14728 {
14729 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14730
14731 temp_retain_fanspeed_value[device_id] = 0;
14732 }
14733 }
14734
14735 hc_thread_mutex_unlock (mux_adl);
14736 }
14737 }
14738
14739 /**
14740 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14741 */
14742
14743 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14744 {
14745 hc_thread_mutex_lock (mux_adl);
14746
14747 if (data.hm_device[device_id].od_version == 6)
14748 {
14749 int ADL_rc;
14750
14751 // check powertune capabilities first, if not available then skip device
14752
14753 int powertune_supported = 0;
14754
14755 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14756 {
14757 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14758
14759 return (-1);
14760 }
14761
14762 if (powertune_supported != 0)
14763 {
14764 // powercontrol settings
14765
14766 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14767
14768 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14769 {
14770 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14771 }
14772
14773 if (ADL_rc != ADL_OK)
14774 {
14775 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14776
14777 return (-1);
14778 }
14779
14780 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14781 {
14782 log_error ("ERROR: Failed to set new ADL PowerControl values");
14783
14784 return (-1);
14785 }
14786
14787 // clocks
14788
14789 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14790
14791 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14792
14793 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)
14794 {
14795 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14796
14797 return (-1);
14798 }
14799
14800 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14801
14802 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14803
14804 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14805 {
14806 log_error ("ERROR: Failed to get ADL device capabilities");
14807
14808 return (-1);
14809 }
14810
14811 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14812 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14813
14814 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14815 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14816
14817 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14818 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14819
14820 // warning if profile has too low max values
14821
14822 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14823 {
14824 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14825 }
14826
14827 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14828 {
14829 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14830 }
14831
14832 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14833
14834 performance_state->iNumberOfPerformanceLevels = 2;
14835
14836 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14837 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14838 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14839 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14840
14841 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)
14842 {
14843 log_info ("ERROR: Failed to set ADL performance state");
14844
14845 return (-1);
14846 }
14847
14848 local_free (performance_state);
14849 }
14850 }
14851
14852 hc_thread_mutex_unlock (mux_adl);
14853 }
14854 #endif // HAVE_HWMON && HAVE_ADL
14855 }
14856
14857 data.kernel_power_all = kernel_power_all;
14858
14859 if (data.quiet == 0) log_info ("");
14860
14861 /**
14862 * In benchmark-mode, inform user which algorithm is checked
14863 */
14864
14865 if (benchmark == 1)
14866 {
14867 quiet = 0;
14868
14869 data.quiet = quiet;
14870
14871 char *hash_type = strhashtype (data.hash_mode); // not a bug
14872
14873 log_info ("Hashtype: %s", hash_type);
14874 log_info ("");
14875 }
14876
14877 /**
14878 * keep track of the progress
14879 */
14880
14881 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14882 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14883 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14884
14885 /**
14886 * open filehandles
14887 */
14888
14889 #if _WIN
14890 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14891 {
14892 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14893
14894 return (-1);
14895 }
14896
14897 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14898 {
14899 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14900
14901 return (-1);
14902 }
14903
14904 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14905 {
14906 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14907
14908 return (-1);
14909 }
14910 #endif
14911
14912 /**
14913 * dictionary pad
14914 */
14915
14916 segment_size *= (1024 * 1024);
14917
14918 data.segment_size = segment_size;
14919
14920 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14921
14922 wl_data->buf = (char *) mymalloc (segment_size);
14923 wl_data->avail = segment_size;
14924 wl_data->incr = segment_size;
14925 wl_data->cnt = 0;
14926 wl_data->pos = 0;
14927
14928 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14929
14930 data.wordlist_mode = wordlist_mode;
14931
14932 cs_t *css_buf = NULL;
14933 uint css_cnt = 0;
14934 uint dictcnt = 0;
14935 uint maskcnt = 1;
14936 char **masks = NULL;
14937 char **dictfiles = NULL;
14938
14939 uint mask_from_file = 0;
14940
14941 if (attack_mode == ATTACK_MODE_STRAIGHT)
14942 {
14943 if (wordlist_mode == WL_MODE_FILE)
14944 {
14945 int wls_left = myargc - (optind + 1);
14946
14947 for (int i = 0; i < wls_left; i++)
14948 {
14949 char *l0_filename = myargv[optind + 1 + i];
14950
14951 struct stat l0_stat;
14952
14953 if (stat (l0_filename, &l0_stat) == -1)
14954 {
14955 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14956
14957 return (-1);
14958 }
14959
14960 uint is_dir = S_ISDIR (l0_stat.st_mode);
14961
14962 if (is_dir == 0)
14963 {
14964 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14965
14966 dictcnt++;
14967
14968 dictfiles[dictcnt - 1] = l0_filename;
14969 }
14970 else
14971 {
14972 // do not allow --keyspace w/ a directory
14973
14974 if (keyspace == 1)
14975 {
14976 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14977
14978 return (-1);
14979 }
14980
14981 char **dictionary_files = NULL;
14982
14983 dictionary_files = scan_directory (l0_filename);
14984
14985 if (dictionary_files != NULL)
14986 {
14987 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14988
14989 for (int d = 0; dictionary_files[d] != NULL; d++)
14990 {
14991 char *l1_filename = dictionary_files[d];
14992
14993 struct stat l1_stat;
14994
14995 if (stat (l1_filename, &l1_stat) == -1)
14996 {
14997 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14998
14999 return (-1);
15000 }
15001
15002 if (S_ISREG (l1_stat.st_mode))
15003 {
15004 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15005
15006 dictcnt++;
15007
15008 dictfiles[dictcnt - 1] = strdup (l1_filename);
15009 }
15010 }
15011 }
15012
15013 local_free (dictionary_files);
15014 }
15015 }
15016
15017 if (dictcnt < 1)
15018 {
15019 log_error ("ERROR: No usable dictionary file found.");
15020
15021 return (-1);
15022 }
15023 }
15024 else if (wordlist_mode == WL_MODE_STDIN)
15025 {
15026 dictcnt = 1;
15027 }
15028 }
15029 else if (attack_mode == ATTACK_MODE_COMBI)
15030 {
15031 // display
15032
15033 char *dictfile1 = myargv[optind + 1 + 0];
15034 char *dictfile2 = myargv[optind + 1 + 1];
15035
15036 // find the bigger dictionary and use as base
15037
15038 FILE *fp1 = NULL;
15039 FILE *fp2 = NULL;
15040
15041 struct stat tmp_stat;
15042
15043 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
15044 {
15045 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15046
15047 return (-1);
15048 }
15049
15050 if (stat (dictfile1, &tmp_stat) == -1)
15051 {
15052 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15053
15054 fclose (fp1);
15055
15056 return (-1);
15057 }
15058
15059 if (S_ISDIR (tmp_stat.st_mode))
15060 {
15061 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
15062
15063 fclose (fp1);
15064
15065 return (-1);
15066 }
15067
15068 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
15069 {
15070 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15071
15072 fclose (fp1);
15073
15074 return (-1);
15075 }
15076
15077 if (stat (dictfile2, &tmp_stat) == -1)
15078 {
15079 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15080
15081 fclose (fp1);
15082 fclose (fp2);
15083
15084 return (-1);
15085 }
15086
15087 if (S_ISDIR (tmp_stat.st_mode))
15088 {
15089 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
15090
15091 fclose (fp1);
15092 fclose (fp2);
15093
15094 return (-1);
15095 }
15096
15097 data.combs_cnt = 1;
15098
15099 data.quiet = 1;
15100
15101 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
15102
15103 data.quiet = quiet;
15104
15105 if (words1_cnt == 0)
15106 {
15107 log_error ("ERROR: %s: empty file", dictfile1);
15108
15109 fclose (fp1);
15110 fclose (fp2);
15111
15112 return (-1);
15113 }
15114
15115 data.combs_cnt = 1;
15116
15117 data.quiet = 1;
15118
15119 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
15120
15121 data.quiet = quiet;
15122
15123 if (words2_cnt == 0)
15124 {
15125 log_error ("ERROR: %s: empty file", dictfile2);
15126
15127 fclose (fp1);
15128 fclose (fp2);
15129
15130 return (-1);
15131 }
15132
15133 fclose (fp1);
15134 fclose (fp2);
15135
15136 data.dictfile = dictfile1;
15137 data.dictfile2 = dictfile2;
15138
15139 if (words1_cnt >= words2_cnt)
15140 {
15141 data.combs_cnt = words2_cnt;
15142 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15143
15144 dictfiles = &data.dictfile;
15145
15146 dictcnt = 1;
15147 }
15148 else
15149 {
15150 data.combs_cnt = words1_cnt;
15151 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15152
15153 dictfiles = &data.dictfile2;
15154
15155 dictcnt = 1;
15156
15157 // we also have to switch wordlist related rules!
15158
15159 char *tmpc = data.rule_buf_l;
15160
15161 data.rule_buf_l = data.rule_buf_r;
15162 data.rule_buf_r = tmpc;
15163
15164 int tmpi = data.rule_len_l;
15165
15166 data.rule_len_l = data.rule_len_r;
15167 data.rule_len_r = tmpi;
15168 }
15169 }
15170 else if (attack_mode == ATTACK_MODE_BF)
15171 {
15172 char *mask = NULL;
15173
15174 maskcnt = 0;
15175
15176 if (benchmark == 0)
15177 {
15178 mask = myargv[optind + 1];
15179
15180 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
15181
15182 if ((optind + 2) <= myargc)
15183 {
15184 struct stat file_stat;
15185
15186 if (stat (mask, &file_stat) == -1)
15187 {
15188 maskcnt = 1;
15189
15190 masks[maskcnt - 1] = mystrdup (mask);
15191 }
15192 else
15193 {
15194 int wls_left = myargc - (optind + 1);
15195
15196 uint masks_avail = INCR_MASKS;
15197
15198 for (int i = 0; i < wls_left; i++)
15199 {
15200 if (i != 0)
15201 {
15202 mask = myargv[optind + 1 + i];
15203
15204 if (stat (mask, &file_stat) == -1)
15205 {
15206 log_error ("ERROR: %s: %s", mask, strerror (errno));
15207
15208 return (-1);
15209 }
15210 }
15211
15212 uint is_file = S_ISREG (file_stat.st_mode);
15213
15214 if (is_file == 1)
15215 {
15216 FILE *mask_fp;
15217
15218 if ((mask_fp = fopen (mask, "r")) == NULL)
15219 {
15220 log_error ("ERROR: %s: %s", mask, strerror (errno));
15221
15222 return (-1);
15223 }
15224
15225 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15226
15227 while (!feof (mask_fp))
15228 {
15229 memset (line_buf, 0, HCBUFSIZ);
15230
15231 int line_len = fgetl (mask_fp, line_buf);
15232
15233 if (line_len == 0) continue;
15234
15235 if (line_buf[0] == '#') continue;
15236
15237 if (masks_avail == maskcnt)
15238 {
15239 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15240
15241 masks_avail += INCR_MASKS;
15242 }
15243
15244 masks[maskcnt] = mystrdup (line_buf);
15245
15246 maskcnt++;
15247 }
15248
15249 myfree (line_buf);
15250
15251 fclose (mask_fp);
15252 }
15253 else
15254 {
15255 log_error ("ERROR: %s: unsupported file-type", mask);
15256
15257 return (-1);
15258 }
15259 }
15260
15261 mask_from_file = 1;
15262 }
15263 }
15264 else
15265 {
15266 custom_charset_1 = (char *) "?l?d?u";
15267 custom_charset_2 = (char *) "?l?d";
15268 custom_charset_3 = (char *) "?l?d*!$@_";
15269
15270 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15271 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15272 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15273
15274 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
15275
15276 wordlist_mode = WL_MODE_MASK;
15277
15278 data.wordlist_mode = wordlist_mode;
15279
15280 increment = 1;
15281
15282 maskcnt = 1;
15283 }
15284 }
15285 else
15286 {
15287 /**
15288 * generate full masks and charsets
15289 */
15290
15291 masks = (char **) mymalloc (sizeof (char *));
15292
15293 switch (hash_mode)
15294 {
15295 case 1731: pw_min = 5;
15296 pw_max = 5;
15297 mask = mystrdup ("?b?b?b?b?b");
15298 break;
15299 case 12500: pw_min = 5;
15300 pw_max = 5;
15301 mask = mystrdup ("?b?b?b?b?b");
15302 break;
15303 default: pw_min = 7;
15304 pw_max = 7;
15305 mask = mystrdup ("?b?b?b?b?b?b?b");
15306 break;
15307 }
15308
15309 maskcnt = 1;
15310
15311 masks[maskcnt - 1] = mystrdup (mask);
15312
15313 wordlist_mode = WL_MODE_MASK;
15314
15315 data.wordlist_mode = wordlist_mode;
15316
15317 increment = 1;
15318 }
15319
15320 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
15321
15322 if (increment)
15323 {
15324 if (increment_min > pw_min) pw_min = increment_min;
15325
15326 if (increment_max < pw_max) pw_max = increment_max;
15327 }
15328 }
15329 else if (attack_mode == ATTACK_MODE_HYBRID1)
15330 {
15331 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15332
15333 // display
15334
15335 char *mask = myargv[myargc - 1];
15336
15337 maskcnt = 0;
15338
15339 masks = (char **) mymalloc (1 * sizeof (char *));
15340
15341 // mod
15342
15343 struct stat file_stat;
15344
15345 if (stat (mask, &file_stat) == -1)
15346 {
15347 maskcnt = 1;
15348
15349 masks[maskcnt - 1] = mystrdup (mask);
15350 }
15351 else
15352 {
15353 uint is_file = S_ISREG (file_stat.st_mode);
15354
15355 if (is_file == 1)
15356 {
15357 FILE *mask_fp;
15358
15359 if ((mask_fp = fopen (mask, "r")) == NULL)
15360 {
15361 log_error ("ERROR: %s: %s", mask, strerror (errno));
15362
15363 return (-1);
15364 }
15365
15366 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15367
15368 uint masks_avail = 1;
15369
15370 while (!feof (mask_fp))
15371 {
15372 memset (line_buf, 0, HCBUFSIZ);
15373
15374 int line_len = fgetl (mask_fp, line_buf);
15375
15376 if (line_len == 0) continue;
15377
15378 if (line_buf[0] == '#') continue;
15379
15380 if (masks_avail == maskcnt)
15381 {
15382 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15383
15384 masks_avail += INCR_MASKS;
15385 }
15386
15387 masks[maskcnt] = mystrdup (line_buf);
15388
15389 maskcnt++;
15390 }
15391
15392 myfree (line_buf);
15393
15394 fclose (mask_fp);
15395
15396 mask_from_file = 1;
15397 }
15398 else
15399 {
15400 maskcnt = 1;
15401
15402 masks[maskcnt - 1] = mystrdup (mask);
15403 }
15404 }
15405
15406 // base
15407
15408 int wls_left = myargc - (optind + 2);
15409
15410 for (int i = 0; i < wls_left; i++)
15411 {
15412 char *filename = myargv[optind + 1 + i];
15413
15414 struct stat file_stat;
15415
15416 if (stat (filename, &file_stat) == -1)
15417 {
15418 log_error ("ERROR: %s: %s", filename, strerror (errno));
15419
15420 return (-1);
15421 }
15422
15423 uint is_dir = S_ISDIR (file_stat.st_mode);
15424
15425 if (is_dir == 0)
15426 {
15427 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15428
15429 dictcnt++;
15430
15431 dictfiles[dictcnt - 1] = filename;
15432 }
15433 else
15434 {
15435 // do not allow --keyspace w/ a directory
15436
15437 if (keyspace == 1)
15438 {
15439 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15440
15441 return (-1);
15442 }
15443
15444 char **dictionary_files = NULL;
15445
15446 dictionary_files = scan_directory (filename);
15447
15448 if (dictionary_files != NULL)
15449 {
15450 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15451
15452 for (int d = 0; dictionary_files[d] != NULL; d++)
15453 {
15454 char *l1_filename = dictionary_files[d];
15455
15456 struct stat l1_stat;
15457
15458 if (stat (l1_filename, &l1_stat) == -1)
15459 {
15460 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15461
15462 return (-1);
15463 }
15464
15465 if (S_ISREG (l1_stat.st_mode))
15466 {
15467 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15468
15469 dictcnt++;
15470
15471 dictfiles[dictcnt - 1] = strdup (l1_filename);
15472 }
15473 }
15474 }
15475
15476 local_free (dictionary_files);
15477 }
15478 }
15479
15480 if (dictcnt < 1)
15481 {
15482 log_error ("ERROR: No usable dictionary file found.");
15483
15484 return (-1);
15485 }
15486
15487 if (increment)
15488 {
15489 maskcnt = 0;
15490
15491 uint mask_min = increment_min; // we can't reject smaller masks here
15492 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15493
15494 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15495 {
15496 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15497
15498 if (cur_mask == NULL) break;
15499
15500 masks[maskcnt] = cur_mask;
15501
15502 maskcnt++;
15503
15504 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15505 }
15506 }
15507 }
15508 else if (attack_mode == ATTACK_MODE_HYBRID2)
15509 {
15510 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15511
15512 // display
15513
15514 char *mask = myargv[optind + 1 + 0];
15515
15516 maskcnt = 0;
15517
15518 masks = (char **) mymalloc (1 * sizeof (char *));
15519
15520 // mod
15521
15522 struct stat file_stat;
15523
15524 if (stat (mask, &file_stat) == -1)
15525 {
15526 maskcnt = 1;
15527
15528 masks[maskcnt - 1] = mystrdup (mask);
15529 }
15530 else
15531 {
15532 uint is_file = S_ISREG (file_stat.st_mode);
15533
15534 if (is_file == 1)
15535 {
15536 FILE *mask_fp;
15537
15538 if ((mask_fp = fopen (mask, "r")) == NULL)
15539 {
15540 log_error ("ERROR: %s: %s", mask, strerror (errno));
15541
15542 return (-1);
15543 }
15544
15545 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15546
15547 uint masks_avail = 1;
15548
15549 while (!feof (mask_fp))
15550 {
15551 memset (line_buf, 0, HCBUFSIZ);
15552
15553 int line_len = fgetl (mask_fp, line_buf);
15554
15555 if (line_len == 0) continue;
15556
15557 if (line_buf[0] == '#') continue;
15558
15559 if (masks_avail == maskcnt)
15560 {
15561 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15562
15563 masks_avail += INCR_MASKS;
15564 }
15565
15566 masks[maskcnt] = mystrdup (line_buf);
15567
15568 maskcnt++;
15569 }
15570
15571 myfree (line_buf);
15572
15573 fclose (mask_fp);
15574
15575 mask_from_file = 1;
15576 }
15577 else
15578 {
15579 maskcnt = 1;
15580
15581 masks[maskcnt - 1] = mystrdup (mask);
15582 }
15583 }
15584
15585 // base
15586
15587 int wls_left = myargc - (optind + 2);
15588
15589 for (int i = 0; i < wls_left; i++)
15590 {
15591 char *filename = myargv[optind + 2 + i];
15592
15593 struct stat file_stat;
15594
15595 if (stat (filename, &file_stat) == -1)
15596 {
15597 log_error ("ERROR: %s: %s", filename, strerror (errno));
15598
15599 return (-1);
15600 }
15601
15602 uint is_dir = S_ISDIR (file_stat.st_mode);
15603
15604 if (is_dir == 0)
15605 {
15606 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15607
15608 dictcnt++;
15609
15610 dictfiles[dictcnt - 1] = filename;
15611 }
15612 else
15613 {
15614 // do not allow --keyspace w/ a directory
15615
15616 if (keyspace == 1)
15617 {
15618 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15619
15620 return (-1);
15621 }
15622
15623 char **dictionary_files = NULL;
15624
15625 dictionary_files = scan_directory (filename);
15626
15627 if (dictionary_files != NULL)
15628 {
15629 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15630
15631 for (int d = 0; dictionary_files[d] != NULL; d++)
15632 {
15633 char *l1_filename = dictionary_files[d];
15634
15635 struct stat l1_stat;
15636
15637 if (stat (l1_filename, &l1_stat) == -1)
15638 {
15639 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15640
15641 return (-1);
15642 }
15643
15644 if (S_ISREG (l1_stat.st_mode))
15645 {
15646 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15647
15648 dictcnt++;
15649
15650 dictfiles[dictcnt - 1] = strdup (l1_filename);
15651 }
15652 }
15653 }
15654
15655 local_free (dictionary_files);
15656 }
15657 }
15658
15659 if (dictcnt < 1)
15660 {
15661 log_error ("ERROR: No usable dictionary file found.");
15662
15663 return (-1);
15664 }
15665
15666 if (increment)
15667 {
15668 maskcnt = 0;
15669
15670 uint mask_min = increment_min; // we can't reject smaller masks here
15671 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15672
15673 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15674 {
15675 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15676
15677 if (cur_mask == NULL) break;
15678
15679 masks[maskcnt] = cur_mask;
15680
15681 maskcnt++;
15682
15683 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15684 }
15685 }
15686 }
15687
15688 data.pw_min = pw_min;
15689 data.pw_max = pw_max;
15690
15691 /**
15692 * weak hash check
15693 */
15694
15695 if (weak_hash_threshold >= salts_cnt)
15696 {
15697 hc_device_param_t *device_param = NULL;
15698
15699 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15700 {
15701 device_param = &data.devices_param[device_id];
15702
15703 if (device_param->skipped) continue;
15704
15705 break;
15706 }
15707
15708 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15709
15710 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15711 {
15712 weak_hash_check (device_param, salt_pos);
15713 }
15714 }
15715
15716 // Display hack, guarantee that there is at least one \r before real start
15717
15718 if (data.quiet == 0) log_info_nn ("");
15719
15720 /**
15721 * status and monitor threads
15722 */
15723
15724 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15725
15726 hc_thread_t i_thread = 0;
15727
15728 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15729 {
15730 hc_thread_create (i_thread, thread_keypress, &benchmark);
15731 }
15732
15733 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15734
15735 uint ni_threads_cnt = 0;
15736
15737 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15738
15739 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15740
15741 ni_threads_cnt++;
15742
15743 /**
15744 * Outfile remove
15745 */
15746
15747 if (keyspace == 0)
15748 {
15749 if (outfile_check_timer != 0)
15750 {
15751 if (data.outfile_check_directory != NULL)
15752 {
15753 if ((hash_mode != 5200) &&
15754 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15755 (hash_mode != 9000))
15756 {
15757 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15758
15759 ni_threads_cnt++;
15760 }
15761 else
15762 {
15763 outfile_check_timer = 0;
15764 }
15765 }
15766 else
15767 {
15768 outfile_check_timer = 0;
15769 }
15770 }
15771 }
15772
15773 /**
15774 * Inform the user if we got some hashes remove because of the pot file remove feature
15775 */
15776
15777 if (data.quiet == 0)
15778 {
15779 if (potfile_remove_cracks > 0)
15780 {
15781 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15782 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15783 }
15784 }
15785
15786 data.outfile_check_timer = outfile_check_timer;
15787
15788 /**
15789 * main loop
15790 */
15791
15792 char **induction_dictionaries = NULL;
15793
15794 int induction_dictionaries_cnt = 0;
15795
15796 hcstat_table_t *root_table_buf = NULL;
15797 hcstat_table_t *markov_table_buf = NULL;
15798
15799 uint initial_restore_done = 0;
15800
15801 data.maskcnt = maskcnt;
15802
15803 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15804 {
15805 if (data.devices_status == STATUS_CRACKED) break;
15806
15807 data.devices_status = STATUS_INIT;
15808
15809 if (maskpos > rd->maskpos)
15810 {
15811 rd->dictpos = 0;
15812 }
15813
15814 rd->maskpos = maskpos;
15815 data.maskpos = maskpos;
15816
15817 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15818 {
15819 char *mask = masks[maskpos];
15820
15821 if (mask_from_file == 1)
15822 {
15823 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15824
15825 char *str_ptr;
15826 uint str_pos;
15827
15828 uint mask_offset = 0;
15829
15830 uint separator_cnt;
15831
15832 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15833 {
15834 str_ptr = strstr (mask + mask_offset, ",");
15835
15836 if (str_ptr == NULL) break;
15837
15838 str_pos = str_ptr - mask;
15839
15840 // escaped separator, i.e. "\,"
15841
15842 if (str_pos > 0)
15843 {
15844 if (mask[str_pos - 1] == '\\')
15845 {
15846 separator_cnt --;
15847
15848 mask_offset = str_pos + 1;
15849
15850 continue;
15851 }
15852 }
15853
15854 // reset the offset
15855
15856 mask_offset = 0;
15857
15858 mask[str_pos] = '\0';
15859
15860 switch (separator_cnt)
15861 {
15862 case 0:
15863 mp_reset_usr (mp_usr, 0);
15864
15865 custom_charset_1 = mask;
15866 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15867 break;
15868
15869 case 1:
15870 mp_reset_usr (mp_usr, 1);
15871
15872 custom_charset_2 = mask;
15873 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15874 break;
15875
15876 case 2:
15877 mp_reset_usr (mp_usr, 2);
15878
15879 custom_charset_3 = mask;
15880 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15881 break;
15882
15883 case 3:
15884 mp_reset_usr (mp_usr, 3);
15885
15886 custom_charset_4 = mask;
15887 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15888 break;
15889 }
15890
15891 mask = mask + str_pos + 1;
15892 }
15893 }
15894
15895 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15896 {
15897 if (maskpos > 0)
15898 {
15899 local_free (css_buf);
15900 local_free (data.root_css_buf);
15901 local_free (data.markov_css_buf);
15902
15903 local_free (masks[maskpos - 1]);
15904 }
15905
15906 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15907
15908 data.mask = mask;
15909 data.css_cnt = css_cnt;
15910 data.css_buf = css_buf;
15911
15912 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15913
15914 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15915
15916 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15917 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15918
15919 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15920
15921 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15922
15923 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15924 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15925
15926 data.root_css_buf = root_css_buf;
15927 data.markov_css_buf = markov_css_buf;
15928
15929 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15930
15931 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15932
15933 local_free (root_table_buf);
15934 local_free (markov_table_buf);
15935
15936 // args
15937
15938 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15939 {
15940 hc_device_param_t *device_param = &data.devices_param[device_id];
15941
15942 if (device_param->skipped) continue;
15943
15944 device_param->kernel_params_mp[0] = &device_param->d_combs;
15945 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15946 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15947
15948 device_param->kernel_params_mp_buf64[3] = 0;
15949 device_param->kernel_params_mp_buf32[4] = css_cnt;
15950 device_param->kernel_params_mp_buf32[5] = 0;
15951 device_param->kernel_params_mp_buf32[6] = 0;
15952 device_param->kernel_params_mp_buf32[7] = 0;
15953
15954 if (attack_mode == ATTACK_MODE_HYBRID1)
15955 {
15956 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15957 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15958 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15959 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15960 }
15961 else if (attack_mode == ATTACK_MODE_HYBRID2)
15962 {
15963 device_param->kernel_params_mp_buf32[5] = 0;
15964 device_param->kernel_params_mp_buf32[6] = 0;
15965 device_param->kernel_params_mp_buf32[7] = 0;
15966 }
15967
15968 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]);
15969 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]);
15970 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]);
15971
15972 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);
15973 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);
15974 }
15975 }
15976 else if (attack_mode == ATTACK_MODE_BF)
15977 {
15978 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15979
15980 if (increment)
15981 {
15982 for (uint i = 0; i < dictcnt; i++)
15983 {
15984 local_free (dictfiles[i]);
15985 }
15986
15987 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15988 {
15989 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15990
15991 if (l1_filename == NULL) break;
15992
15993 dictcnt++;
15994
15995 dictfiles[dictcnt - 1] = l1_filename;
15996 }
15997 }
15998 else
15999 {
16000 dictcnt++;
16001
16002 dictfiles[dictcnt - 1] = mask;
16003 }
16004
16005 if (dictcnt == 0)
16006 {
16007 log_error ("ERROR: Mask is too small");
16008
16009 return (-1);
16010 }
16011 }
16012 }
16013
16014 free (induction_dictionaries);
16015
16016 // induction_dictionaries_cnt = 0; // implied
16017
16018 if (attack_mode != ATTACK_MODE_BF)
16019 {
16020 if (keyspace == 0)
16021 {
16022 induction_dictionaries = scan_directory (induction_directory);
16023
16024 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16025 }
16026 }
16027
16028 if (induction_dictionaries_cnt)
16029 {
16030 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16031 }
16032
16033 /**
16034 * prevent the user from using --keyspace together w/ maskfile and or dictfile
16035 */
16036 if (keyspace == 1)
16037 {
16038 if ((maskcnt > 1) || (dictcnt > 1))
16039 {
16040 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
16041
16042 return (-1);
16043 }
16044 }
16045
16046 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
16047 {
16048 char *subid = logfile_generate_subid ();
16049
16050 data.subid = subid;
16051
16052 logfile_sub_msg ("START");
16053
16054 data.devices_status = STATUS_INIT;
16055
16056 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
16057 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
16058 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
16059
16060 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
16061
16062 data.cpt_pos = 0;
16063
16064 data.cpt_start = time (NULL);
16065
16066 data.cpt_total = 0;
16067
16068 if (data.restore == 0)
16069 {
16070 rd->words_cur = skip;
16071
16072 skip = 0;
16073
16074 data.skip = 0;
16075 }
16076
16077 data.ms_paused = 0;
16078
16079 data.words_cur = rd->words_cur;
16080
16081 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16082 {
16083 hc_device_param_t *device_param = &data.devices_param[device_id];
16084
16085 if (device_param->skipped) continue;
16086
16087 device_param->speed_pos = 0;
16088
16089 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
16090 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
16091
16092 device_param->exec_pos = 0;
16093
16094 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
16095
16096 device_param->kernel_power = device_param->kernel_power_user;
16097
16098 device_param->outerloop_pos = 0;
16099 device_param->outerloop_left = 0;
16100 device_param->innerloop_pos = 0;
16101 device_param->innerloop_left = 0;
16102
16103 // some more resets:
16104
16105 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
16106
16107 device_param->pws_cnt = 0;
16108
16109 device_param->words_off = 0;
16110 device_param->words_done = 0;
16111 }
16112
16113 data.kernel_power_div = 0;
16114
16115 // figure out some workload
16116
16117 if (attack_mode == ATTACK_MODE_STRAIGHT)
16118 {
16119 if (data.wordlist_mode == WL_MODE_FILE)
16120 {
16121 char *dictfile = NULL;
16122
16123 if (induction_dictionaries_cnt)
16124 {
16125 dictfile = induction_dictionaries[0];
16126 }
16127 else
16128 {
16129 dictfile = dictfiles[dictpos];
16130 }
16131
16132 data.dictfile = dictfile;
16133
16134 logfile_sub_string (dictfile);
16135
16136 for (uint i = 0; i < rp_files_cnt; i++)
16137 {
16138 logfile_sub_var_string ("rulefile", rp_files[i]);
16139 }
16140
16141 FILE *fd2 = fopen (dictfile, "rb");
16142
16143 if (fd2 == NULL)
16144 {
16145 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16146
16147 return (-1);
16148 }
16149
16150 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16151
16152 fclose (fd2);
16153
16154 if (data.words_cnt == 0)
16155 {
16156 if (data.devices_status == STATUS_CRACKED) break;
16157 if (data.devices_status == STATUS_ABORTED) break;
16158
16159 dictpos++;
16160
16161 continue;
16162 }
16163 }
16164 }
16165 else if (attack_mode == ATTACK_MODE_COMBI)
16166 {
16167 char *dictfile = data.dictfile;
16168 char *dictfile2 = data.dictfile2;
16169
16170 logfile_sub_string (dictfile);
16171 logfile_sub_string (dictfile2);
16172
16173 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
16174 {
16175 FILE *fd2 = fopen (dictfile, "rb");
16176
16177 if (fd2 == NULL)
16178 {
16179 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16180
16181 return (-1);
16182 }
16183
16184 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16185
16186 fclose (fd2);
16187 }
16188 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
16189 {
16190 FILE *fd2 = fopen (dictfile2, "rb");
16191
16192 if (fd2 == NULL)
16193 {
16194 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16195
16196 return (-1);
16197 }
16198
16199 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
16200
16201 fclose (fd2);
16202 }
16203
16204 if (data.words_cnt == 0)
16205 {
16206 if (data.devices_status == STATUS_CRACKED) break;
16207 if (data.devices_status == STATUS_ABORTED) break;
16208
16209 dictpos++;
16210
16211 continue;
16212 }
16213 }
16214 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16215 {
16216 char *dictfile = NULL;
16217
16218 if (induction_dictionaries_cnt)
16219 {
16220 dictfile = induction_dictionaries[0];
16221 }
16222 else
16223 {
16224 dictfile = dictfiles[dictpos];
16225 }
16226
16227 data.dictfile = dictfile;
16228
16229 char *mask = data.mask;
16230
16231 logfile_sub_string (dictfile);
16232 logfile_sub_string (mask);
16233
16234 FILE *fd2 = fopen (dictfile, "rb");
16235
16236 if (fd2 == NULL)
16237 {
16238 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16239
16240 return (-1);
16241 }
16242
16243 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16244
16245 fclose (fd2);
16246
16247 if (data.words_cnt == 0)
16248 {
16249 if (data.devices_status == STATUS_CRACKED) break;
16250 if (data.devices_status == STATUS_ABORTED) break;
16251
16252 dictpos++;
16253
16254 continue;
16255 }
16256 }
16257 else if (attack_mode == ATTACK_MODE_BF)
16258 {
16259 local_free (css_buf);
16260 local_free (data.root_css_buf);
16261 local_free (data.markov_css_buf);
16262
16263 char *mask = dictfiles[dictpos];
16264
16265 logfile_sub_string (mask);
16266
16267 // base
16268
16269 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16270
16271 if (opts_type & OPTS_TYPE_PT_UNICODE)
16272 {
16273 uint css_cnt_unicode = css_cnt * 2;
16274
16275 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
16276
16277 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
16278 {
16279 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
16280
16281 css_buf_unicode[j + 1].cs_buf[0] = 0;
16282 css_buf_unicode[j + 1].cs_len = 1;
16283 }
16284
16285 free (css_buf);
16286
16287 css_buf = css_buf_unicode;
16288 css_cnt = css_cnt_unicode;
16289 }
16290
16291 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
16292
16293 uint mask_min = pw_min;
16294 uint mask_max = pw_max;
16295
16296 if (opts_type & OPTS_TYPE_PT_UNICODE)
16297 {
16298 mask_min *= 2;
16299 mask_max *= 2;
16300 }
16301
16302 if ((css_cnt < mask_min) || (css_cnt > mask_max))
16303 {
16304 if (css_cnt < mask_min)
16305 {
16306 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
16307 }
16308
16309 if (css_cnt > mask_max)
16310 {
16311 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
16312 }
16313
16314 // skip to next mask
16315
16316 dictpos++;
16317
16318 rd->dictpos = dictpos;
16319
16320 logfile_sub_msg ("STOP");
16321
16322 continue;
16323 }
16324
16325 uint save_css_cnt = css_cnt;
16326
16327 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16328 {
16329 if (opti_type & OPTI_TYPE_APPENDED_SALT)
16330 {
16331 uint salt_len = (uint) data.salts_buf[0].salt_len;
16332 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
16333
16334 uint css_cnt_salt = css_cnt + salt_len;
16335
16336 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
16337
16338 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
16339
16340 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
16341 {
16342 css_buf_salt[j].cs_buf[0] = salt_buf[i];
16343 css_buf_salt[j].cs_len = 1;
16344 }
16345
16346 free (css_buf);
16347
16348 css_buf = css_buf_salt;
16349 css_cnt = css_cnt_salt;
16350 }
16351 }
16352
16353 data.mask = mask;
16354 data.css_cnt = css_cnt;
16355 data.css_buf = css_buf;
16356
16357 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
16358
16359 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16360
16361 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16362
16363 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16364 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16365
16366 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16367
16368 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16369
16370 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16371 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16372
16373 data.root_css_buf = root_css_buf;
16374 data.markov_css_buf = markov_css_buf;
16375
16376 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16377
16378 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16379
16380 local_free (root_table_buf);
16381 local_free (markov_table_buf);
16382
16383 // copy + args
16384
16385 uint css_cnt_l = css_cnt;
16386 uint css_cnt_r;
16387
16388 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16389 {
16390 if (save_css_cnt < 6)
16391 {
16392 css_cnt_r = 1;
16393 }
16394 else if (save_css_cnt == 6)
16395 {
16396 css_cnt_r = 2;
16397 }
16398 else
16399 {
16400 if (opts_type & OPTS_TYPE_PT_UNICODE)
16401 {
16402 if (save_css_cnt == 8 || save_css_cnt == 10)
16403 {
16404 css_cnt_r = 2;
16405 }
16406 else
16407 {
16408 css_cnt_r = 4;
16409 }
16410 }
16411 else
16412 {
16413 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
16414 {
16415 css_cnt_r = 3;
16416 }
16417 else
16418 {
16419 css_cnt_r = 4;
16420 }
16421 }
16422 }
16423 }
16424 else
16425 {
16426 css_cnt_r = 1;
16427
16428 /* unfinished code?
16429 int sum = css_buf[css_cnt_r - 1].cs_len;
16430
16431 for (uint i = 1; i < 4 && i < css_cnt; i++)
16432 {
16433 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
16434
16435 css_cnt_r++;
16436
16437 sum *= css_buf[css_cnt_r - 1].cs_len;
16438 }
16439 */
16440 }
16441
16442 css_cnt_l -= css_cnt_r;
16443
16444 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
16445
16446 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16447 {
16448 hc_device_param_t *device_param = &data.devices_param[device_id];
16449
16450 if (device_param->skipped) continue;
16451
16452 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
16453 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
16454 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
16455
16456 device_param->kernel_params_mp_l_buf64[3] = 0;
16457 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
16458 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
16459 device_param->kernel_params_mp_l_buf32[6] = 0;
16460 device_param->kernel_params_mp_l_buf32[7] = 0;
16461 device_param->kernel_params_mp_l_buf32[8] = 0;
16462
16463 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
16464 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
16465 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
16466 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
16467
16468 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
16469 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
16470 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
16471
16472 device_param->kernel_params_mp_r_buf64[3] = 0;
16473 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
16474 device_param->kernel_params_mp_r_buf32[5] = 0;
16475 device_param->kernel_params_mp_r_buf32[6] = 0;
16476 device_param->kernel_params_mp_r_buf32[7] = 0;
16477
16478 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]);
16479 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]);
16480 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]);
16481
16482 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]);
16483 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]);
16484 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]);
16485
16486 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);
16487 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);
16488 }
16489 }
16490
16491 u64 words_base = data.words_cnt;
16492
16493 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16494 {
16495 if (data.kernel_rules_cnt)
16496 {
16497 words_base /= data.kernel_rules_cnt;
16498 }
16499 }
16500 else if (data.attack_kern == ATTACK_KERN_COMBI)
16501 {
16502 if (data.combs_cnt)
16503 {
16504 words_base /= data.combs_cnt;
16505 }
16506 }
16507 else if (data.attack_kern == ATTACK_KERN_BF)
16508 {
16509 if (data.bfs_cnt)
16510 {
16511 words_base /= data.bfs_cnt;
16512 }
16513 }
16514
16515 data.words_base = words_base;
16516
16517 if (keyspace == 1)
16518 {
16519 log_info ("%llu", (unsigned long long int) words_base);
16520
16521 return (0);
16522 }
16523
16524 if (data.words_cur > data.words_base)
16525 {
16526 log_error ("ERROR: restore value greater keyspace");
16527
16528 return (-1);
16529 }
16530
16531 if (data.words_cur)
16532 {
16533 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16534 {
16535 for (uint i = 0; i < data.salts_cnt; i++)
16536 {
16537 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16538 }
16539 }
16540 else if (data.attack_kern == ATTACK_KERN_COMBI)
16541 {
16542 for (uint i = 0; i < data.salts_cnt; i++)
16543 {
16544 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16545 }
16546 }
16547 else if (data.attack_kern == ATTACK_KERN_BF)
16548 {
16549 for (uint i = 0; i < data.salts_cnt; i++)
16550 {
16551 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16552 }
16553 }
16554 }
16555
16556 /*
16557 * Inform user about possible slow speeds
16558 */
16559
16560 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16561 {
16562 if (data.words_base < kernel_power_all)
16563 {
16564 if (quiet == 0)
16565 {
16566 log_info ("");
16567 log_info ("ATTENTION!");
16568 log_info (" The wordlist or mask you are using is too small.");
16569 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
16570 log_info (" The cracking speed will drop.");
16571 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16572 log_info ("");
16573 }
16574 }
16575 }
16576
16577 /*
16578 * Update loopback file
16579 */
16580
16581 if (loopback == 1)
16582 {
16583 time_t now;
16584
16585 time (&now);
16586
16587 uint random_num = get_random_num (0, 9999);
16588
16589 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16590
16591 data.loopback_file = loopback_file;
16592 }
16593
16594 /*
16595 * Update dictionary statistic
16596 */
16597
16598 if (keyspace == 0)
16599 {
16600 dictstat_fp = fopen (dictstat, "wb");
16601
16602 if (dictstat_fp)
16603 {
16604 lock_file (dictstat_fp);
16605
16606 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16607
16608 fclose (dictstat_fp);
16609 }
16610 }
16611
16612 data.devices_status = STATUS_RUNNING;
16613
16614 if (initial_restore_done == 0)
16615 {
16616 if (data.restore_disable == 0) cycle_restore ();
16617
16618 initial_restore_done = 1;
16619 }
16620
16621 hc_timer_set (&data.timer_running);
16622
16623 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16624 {
16625 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16626 {
16627 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16628 if (quiet == 0) fflush (stdout);
16629 }
16630 }
16631 else if (wordlist_mode == WL_MODE_STDIN)
16632 {
16633 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16634 if (data.quiet == 0) log_info ("");
16635 }
16636
16637 time_t runtime_start;
16638
16639 time (&runtime_start);
16640
16641 data.runtime_start = runtime_start;
16642
16643 /**
16644 * create cracker threads
16645 */
16646
16647 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
16648
16649 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16650 {
16651 hc_device_param_t *device_param = &devices_param[device_id];
16652
16653 if (wordlist_mode == WL_MODE_STDIN)
16654 {
16655 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16656 }
16657 else
16658 {
16659 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16660 }
16661 }
16662
16663 // wait for crack threads to exit
16664
16665 hc_thread_wait (data.devices_cnt, c_threads);
16666
16667 local_free (c_threads);
16668
16669 data.restore = 0;
16670
16671 // finalize task
16672
16673 logfile_sub_var_uint ("status-after-work", data.devices_status);
16674
16675 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16676
16677 if (data.devices_status == STATUS_CRACKED) break;
16678 if (data.devices_status == STATUS_ABORTED) break;
16679
16680 if (data.devices_status == STATUS_BYPASS)
16681 {
16682 data.devices_status = STATUS_RUNNING;
16683 }
16684
16685 if (induction_dictionaries_cnt)
16686 {
16687 unlink (induction_dictionaries[0]);
16688 }
16689
16690 free (induction_dictionaries);
16691
16692 if (attack_mode != ATTACK_MODE_BF)
16693 {
16694 induction_dictionaries = scan_directory (induction_directory);
16695
16696 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16697 }
16698
16699 if (benchmark == 0)
16700 {
16701 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16702 {
16703 if (quiet == 0) clear_prompt ();
16704
16705 if (quiet == 0) log_info ("");
16706
16707 if (status == 1)
16708 {
16709 status_display ();
16710 }
16711 else
16712 {
16713 if (quiet == 0) status_display ();
16714 }
16715
16716 if (quiet == 0) log_info ("");
16717 }
16718 }
16719
16720 if (attack_mode == ATTACK_MODE_BF)
16721 {
16722 dictpos++;
16723
16724 rd->dictpos = dictpos;
16725 }
16726 else
16727 {
16728 if (induction_dictionaries_cnt)
16729 {
16730 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16731 }
16732 else
16733 {
16734 dictpos++;
16735
16736 rd->dictpos = dictpos;
16737 }
16738 }
16739
16740 time_t runtime_stop;
16741
16742 time (&runtime_stop);
16743
16744 data.runtime_stop = runtime_stop;
16745
16746 logfile_sub_uint (runtime_start);
16747 logfile_sub_uint (runtime_stop);
16748
16749 logfile_sub_msg ("STOP");
16750
16751 global_free (subid);
16752 }
16753
16754 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16755
16756 if (data.devices_status == STATUS_CRACKED) break;
16757 if (data.devices_status == STATUS_ABORTED) break;
16758 if (data.devices_status == STATUS_QUIT) break;
16759
16760 if (data.devices_status == STATUS_BYPASS)
16761 {
16762 data.devices_status = STATUS_RUNNING;
16763 }
16764 }
16765
16766 // 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
16767
16768 if (attack_mode == ATTACK_MODE_STRAIGHT)
16769 {
16770 if (data.wordlist_mode == WL_MODE_FILE)
16771 {
16772 if (data.dictfile == NULL)
16773 {
16774 if (dictfiles != NULL)
16775 {
16776 data.dictfile = dictfiles[0];
16777
16778 hc_timer_set (&data.timer_running);
16779 }
16780 }
16781 }
16782 }
16783 // NOTE: combi is okay because it is already set beforehand
16784 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16785 {
16786 if (data.dictfile == NULL)
16787 {
16788 if (dictfiles != NULL)
16789 {
16790 hc_timer_set (&data.timer_running);
16791
16792 data.dictfile = dictfiles[0];
16793 }
16794 }
16795 }
16796 else if (attack_mode == ATTACK_MODE_BF)
16797 {
16798 if (data.mask == NULL)
16799 {
16800 hc_timer_set (&data.timer_running);
16801
16802 data.mask = masks[0];
16803 }
16804 }
16805
16806 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16807 {
16808 data.devices_status = STATUS_EXHAUSTED;
16809 }
16810
16811 // if cracked / aborted remove last induction dictionary
16812
16813 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16814 {
16815 struct stat induct_stat;
16816
16817 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16818 {
16819 unlink (induction_dictionaries[file_pos]);
16820 }
16821 }
16822
16823 // wait for non-interactive threads
16824
16825 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16826 {
16827 hc_thread_wait (1, &ni_threads[thread_idx]);
16828 }
16829
16830 local_free (ni_threads);
16831
16832 // wait for interactive threads
16833
16834 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16835 {
16836 hc_thread_wait (1, &i_thread);
16837 }
16838
16839 // we dont need restore file anymore
16840 if (data.restore_disable == 0)
16841 {
16842 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16843 {
16844 unlink (eff_restore_file);
16845 unlink (new_restore_file);
16846 }
16847 else
16848 {
16849 cycle_restore ();
16850 }
16851 }
16852
16853 // finally save left hashes
16854
16855 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16856 {
16857 save_hash ();
16858 }
16859
16860 /**
16861 * Clean up
16862 */
16863
16864 if (benchmark == 1)
16865 {
16866 status_benchmark ();
16867
16868 log_info ("");
16869 }
16870 else
16871 {
16872 if (quiet == 0) clear_prompt ();
16873
16874 if (quiet == 0) log_info ("");
16875
16876 if (status == 1)
16877 {
16878 status_display ();
16879 }
16880 else
16881 {
16882 if (quiet == 0) status_display ();
16883 }
16884
16885 if (quiet == 0) log_info ("");
16886 }
16887
16888 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16889 {
16890 hc_device_param_t *device_param = &data.devices_param[device_id];
16891
16892 if (device_param->skipped) continue;
16893
16894 local_free (device_param->result);
16895
16896 local_free (device_param->combs_buf);
16897
16898 local_free (device_param->hooks_buf);
16899
16900 local_free (device_param->device_name);
16901
16902 local_free (device_param->device_name_chksum);
16903
16904 local_free (device_param->device_version);
16905
16906 local_free (device_param->driver_version);
16907
16908 if (device_param->pws_buf) myfree (device_param->pws_buf);
16909 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
16910 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
16911 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
16912 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
16913 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
16914 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
16915 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
16916 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
16917 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
16918 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
16919 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
16920 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
16921 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
16922 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
16923 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
16924 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
16925 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
16926 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
16927 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
16928 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
16929 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
16930 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
16931 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
16932 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
16933 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
16934 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
16935 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
16936 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
16937
16938 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
16939 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
16940 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
16941 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
16942 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
16943 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
16944 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
16945 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
16946 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
16947 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
16948
16949 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
16950 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
16951 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
16952
16953 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
16954 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
16955 }
16956
16957 // reset default fan speed
16958
16959 #ifdef HAVE_HWMON
16960 if (gpu_temp_disable == 0)
16961 {
16962 #ifdef HAVE_ADL
16963 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16964 {
16965 hc_thread_mutex_lock (mux_adl);
16966
16967 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16968 {
16969 hc_device_param_t *device_param = &data.devices_param[device_id];
16970
16971 if (device_param->skipped) continue;
16972
16973 if (data.hm_device[device_id].fan_supported == 1)
16974 {
16975 int fanspeed = temp_retain_fanspeed_value[device_id];
16976
16977 if (fanspeed == -1) continue;
16978
16979 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
16980
16981 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
16982 }
16983 }
16984
16985 hc_thread_mutex_unlock (mux_adl);
16986 }
16987 #endif // HAVE_ADL
16988 }
16989
16990 #ifdef HAVE_ADL
16991 // reset power tuning
16992
16993 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16994 {
16995 hc_thread_mutex_lock (mux_adl);
16996
16997 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16998 {
16999 hc_device_param_t *device_param = &data.devices_param[device_id];
17000
17001 if (device_param->skipped) continue;
17002
17003 if (data.hm_device[device_id].od_version == 6)
17004 {
17005 // check powertune capabilities first, if not available then skip device
17006
17007 int powertune_supported = 0;
17008
17009 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
17010 {
17011 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
17012
17013 return (-1);
17014 }
17015
17016 if (powertune_supported != 0)
17017 {
17018 // powercontrol settings
17019
17020 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)
17021 {
17022 log_info ("ERROR: Failed to restore the ADL PowerControl values");
17023
17024 return (-1);
17025 }
17026
17027 // clocks
17028
17029 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
17030
17031 performance_state->iNumberOfPerformanceLevels = 2;
17032
17033 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
17034 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
17035 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
17036 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
17037
17038 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)
17039 {
17040 log_info ("ERROR: Failed to restore ADL performance state");
17041
17042 return (-1);
17043 }
17044
17045 local_free (performance_state);
17046 }
17047 }
17048 }
17049
17050 hc_thread_mutex_unlock (mux_adl);
17051 }
17052 #endif // HAVE_ADL
17053
17054 if (gpu_temp_disable == 0)
17055 {
17056 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
17057 if (data.hm_nv)
17058 {
17059 #if defined(LINUX) && defined(HAVE_NVML)
17060
17061 hm_NVML_nvmlShutdown (data.hm_nv);
17062
17063 nvml_close (data.hm_nv);
17064
17065 #elif defined(WIN) && (HAVE_NVAPI)
17066
17067 hm_NvAPI_Unload (data.hm_nv);
17068
17069 nvapi_close (data.hm_nv);
17070
17071 #endif
17072
17073 data.hm_nv = NULL;
17074 }
17075 #endif
17076
17077 #ifdef HAVE_ADL
17078 if (data.hm_amd)
17079 {
17080 hm_ADL_Main_Control_Destroy (data.hm_amd);
17081
17082 adl_close (data.hm_amd);
17083 data.hm_amd = NULL;
17084 }
17085 #endif
17086 }
17087 #endif // HAVE_HWMON
17088
17089 // free memory
17090
17091 local_free (masks);
17092
17093 local_free (dictstat_base);
17094
17095 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
17096 {
17097 pot_t *pot_ptr = &pot[pot_pos];
17098
17099 hash_t *hash = &pot_ptr->hash;
17100
17101 local_free (hash->digest);
17102
17103 if (isSalted)
17104 {
17105 local_free (hash->salt);
17106 }
17107 }
17108
17109 local_free (pot);
17110
17111 local_free (all_kernel_rules_cnt);
17112 local_free (all_kernel_rules_buf);
17113
17114 local_free (wl_data->buf);
17115 local_free (wl_data);
17116
17117 local_free (bitmap_s1_a);
17118 local_free (bitmap_s1_b);
17119 local_free (bitmap_s1_c);
17120 local_free (bitmap_s1_d);
17121 local_free (bitmap_s2_a);
17122 local_free (bitmap_s2_b);
17123 local_free (bitmap_s2_c);
17124 local_free (bitmap_s2_d);
17125
17126 #ifdef HAVE_HWMON
17127 local_free (temp_retain_fanspeed_value);
17128 #ifdef HAVE_ADL
17129 local_free (od_clock_mem_status);
17130 local_free (od_power_control_status);
17131 #endif // ADL
17132 #endif
17133
17134 global_free (devices_param);
17135
17136 global_free (kernel_rules_buf);
17137
17138 global_free (root_css_buf);
17139 global_free (markov_css_buf);
17140
17141 global_free (digests_buf);
17142 global_free (digests_shown);
17143 global_free (digests_shown_tmp);
17144
17145 global_free (salts_buf);
17146 global_free (salts_shown);
17147
17148 global_free (esalts_buf);
17149
17150 global_free (words_progress_done);
17151 global_free (words_progress_rejected);
17152 global_free (words_progress_restored);
17153
17154 if (pot_fp) fclose (pot_fp);
17155
17156 if (data.devices_status == STATUS_QUIT) break;
17157 }
17158
17159 // destroy others mutex
17160
17161 hc_thread_mutex_delete (mux_dispatcher);
17162 hc_thread_mutex_delete (mux_counter);
17163 hc_thread_mutex_delete (mux_display);
17164 hc_thread_mutex_delete (mux_adl);
17165
17166 // free memory
17167
17168 local_free (eff_restore_file);
17169 local_free (new_restore_file);
17170
17171 local_free (rd);
17172
17173 // tuning db
17174
17175 tuning_db_destroy (tuning_db);
17176
17177 // loopback
17178
17179 local_free (loopback_file);
17180
17181 if (loopback == 1) unlink (loopback_file);
17182
17183 // induction directory
17184
17185 if (induction_dir == NULL)
17186 {
17187 if (attack_mode != ATTACK_MODE_BF)
17188 {
17189 if (rmdir (induction_directory) == -1)
17190 {
17191 if (errno == ENOENT)
17192 {
17193 // good, we can ignore
17194 }
17195 else if (errno == ENOTEMPTY)
17196 {
17197 // good, we can ignore
17198 }
17199 else
17200 {
17201 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
17202
17203 return (-1);
17204 }
17205 }
17206
17207 local_free (induction_directory);
17208 }
17209 }
17210
17211 // outfile-check directory
17212
17213 if (outfile_check_dir == NULL)
17214 {
17215 if (rmdir (outfile_check_directory) == -1)
17216 {
17217 if (errno == ENOENT)
17218 {
17219 // good, we can ignore
17220 }
17221 else if (errno == ENOTEMPTY)
17222 {
17223 // good, we can ignore
17224 }
17225 else
17226 {
17227 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
17228
17229 return (-1);
17230 }
17231 }
17232
17233 local_free (outfile_check_directory);
17234 }
17235
17236 time_t proc_stop;
17237
17238 time (&proc_stop);
17239
17240 logfile_top_uint (proc_start);
17241 logfile_top_uint (proc_stop);
17242
17243 logfile_top_msg ("STOP");
17244
17245 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
17246 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
17247
17248 if (data.ocl) ocl_close (data.ocl);
17249
17250 if (data.devices_status == STATUS_ABORTED) return 2;
17251 if (data.devices_status == STATUS_QUIT) return 2;
17252 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
17253 if (data.devices_status == STATUS_EXHAUSTED) return 1;
17254 if (data.devices_status == STATUS_CRACKED) return 0;
17255
17256 return -1;
17257 }
Hashcat additions to support pwdhash