projects / hashcat.git / blob
? search:


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