projects / hashcat.git / blob
? search:


9d78debf2f9cf5857cecfc7426a7a65ebf083cbc
[hashcat.git] / src / oclHashcat.c
1 /**
2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
5 *
6 * License.....: MIT
7 */
8
9 #ifdef OSX
10 #include <stdio.h>
11 #endif
12
13 #include <common.h>
14 #include <shared.h>
15 #include <rp_kernel_on_cpu.h>
16 #include <getopt.h>
17
18 const char *PROGNAME = "oclHashcat";
19 const uint VERSION_BIN = 210;
20 const uint RESTORE_MIN = 210;
21
22 double TARGET_MS_PROFILE[3] = { 8, 16, 96 };
23
24 #define INCR_RULES 10000
25 #define INCR_SALTS 100000
26 #define INCR_MASKS 1000
27 #define INCR_POT 1000
28
29 #define USAGE 0
30 #define VERSION 0
31 #define QUIET 0
32 #define MARKOV_THRESHOLD 0
33 #define MARKOV_DISABLE 0
34 #define MARKOV_CLASSIC 0
35 #define BENCHMARK 0
36 #define BENCHMARK_REPEATS 2
37 #define RESTORE 0
38 #define RESTORE_TIMER 60
39 #define RESTORE_DISABLE 0
40 #define STATUS 0
41 #define STATUS_TIMER 10
42 #define STATUS_AUTOMAT 0
43 #define LOOPBACK 0
44 #define WEAK_HASH_THRESHOLD 100
45 #define SHOW 0
46 #define LEFT 0
47 #define USERNAME 0
48 #define REMOVE 0
49 #define REMOVE_TIMER 60
50 #define SKIP 0
51 #define LIMIT 0
52 #define KEYSPACE 0
53 #define POTFILE_DISABLE 0
54 #define DEBUG_MODE 0
55 #define RP_GEN 0
56 #define RP_GEN_FUNC_MIN 1
57 #define RP_GEN_FUNC_MAX 4
58 #define RP_GEN_SEED 0
59 #define RULE_BUF_L ":"
60 #define RULE_BUF_R ":"
61 #define FORCE 0
62 #define RUNTIME 0
63 #define HEX_CHARSET 0
64 #define HEX_SALT 0
65 #define HEX_WORDLIST 0
66 #define OUTFILE_FORMAT 3
67 #define OUTFILE_AUTOHEX 1
68 #define OUTFILE_CHECK_TIMER 5
69 #define ATTACK_MODE 0
70 #define HASH_MODE 0
71 #define SEGMENT_SIZE 32
72 #define INCREMENT 0
73 #define INCREMENT_MIN 1
74 #define INCREMENT_MAX PW_MAX
75 #define SEPARATOR ':'
76 #define BITMAP_MIN 16
77 #define BITMAP_MAX 24
78 #define GPU_TEMP_DISABLE 0
79 #define GPU_TEMP_ABORT 90
80 #define GPU_TEMP_RETAIN 80
81 #define WORKLOAD_PROFILE 2
82 #define KERNEL_ACCEL 0
83 #define KERNEL_LOOPS 0
84 #define KERNEL_RULES 1024
85 #define KERNEL_COMBS 1024
86 #define KERNEL_BFS 1024
87 #define KERNEL_THREADS 64
88 #define POWERTUNE_ENABLE 0
89 #define LOGFILE_DISABLE 0
90 #define SCRYPT_TMTO 0
91 #define OPENCL_VECTOR_WIDTH 0
92
93 #define WL_MODE_STDIN 1
94 #define WL_MODE_FILE 2
95 #define WL_MODE_MASK 3
96
97 #define HL_MODE_FILE 4
98 #define HL_MODE_ARG 5
99
100 #define HLFMTS_CNT 11
101 #define HLFMT_HASHCAT 0
102 #define HLFMT_PWDUMP 1
103 #define HLFMT_PASSWD 2
104 #define HLFMT_SHADOW 3
105 #define HLFMT_DCC 4
106 #define HLFMT_DCC2 5
107 #define HLFMT_NETNTLM1 7
108 #define HLFMT_NETNTLM2 8
109 #define HLFMT_NSLDAP 9
110 #define HLFMT_NSLDAPS 10
111
112 #define HLFMT_TEXT_HASHCAT "native hashcat"
113 #define HLFMT_TEXT_PWDUMP "pwdump"
114 #define HLFMT_TEXT_PASSWD "passwd"
115 #define HLFMT_TEXT_SHADOW "shadow"
116 #define HLFMT_TEXT_DCC "DCC"
117 #define HLFMT_TEXT_DCC2 "DCC 2"
118 #define HLFMT_TEXT_NETNTLM1 "NetNTLMv1"
119 #define HLFMT_TEXT_NETNTLM2 "NetNTLMv2"
120 #define HLFMT_TEXT_NSLDAP "nsldap"
121 #define HLFMT_TEXT_NSLDAPS "nsldaps"
122
123 #define ATTACK_MODE_STRAIGHT 0
124 #define ATTACK_MODE_COMBI 1
125 #define ATTACK_MODE_TOGGLE 2
126 #define ATTACK_MODE_BF 3
127 #define ATTACK_MODE_PERM 4
128 #define ATTACK_MODE_TABLE 5
129 #define ATTACK_MODE_HYBRID1 6
130 #define ATTACK_MODE_HYBRID2 7
131 #define ATTACK_MODE_NONE 100
132
133 #define ATTACK_KERN_STRAIGHT 0
134 #define ATTACK_KERN_COMBI 1
135 #define ATTACK_KERN_BF 3
136 #define ATTACK_KERN_NONE 100
137
138 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
139 #define ATTACK_EXEC_INSIDE_KERNEL 11
140
141 #define COMBINATOR_MODE_BASE_LEFT 10001
142 #define COMBINATOR_MODE_BASE_RIGHT 10002
143
144 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
145 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
146
147 #define MAX_CUT_TRIES 4
148
149 #define MAX_DICTSTAT 10000
150
151 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 133
152
153 #define global_free(attr) \
154 { \
155 myfree ((void *) data.attr); \
156 \
157 data.attr = NULL; \
158 }
159
160 #define local_free(attr) \
161 { \
162 myfree ((void *) attr); \
163 \
164 attr = NULL; \
165 }
166
167 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
168 {
169 900,
170 0,
171 5100,
172 100,
173 1400,
174 10800,
175 1700,
176 5000,
177 10100,
178 6000,
179 6100,
180 6900,
181 11700,
182 11800,
183 400,
184 8900,
185 11900,
186 12000,
187 10900,
188 12100,
189 23,
190 2500,
191 5300,
192 5400,
193 5500,
194 5600,
195 7300,
196 7500,
197 13100,
198 8300,
199 11100,
200 11200,
201 11400,
202 121,
203 2611,
204 2711,
205 2811,
206 8400,
207 11,
208 2612,
209 7900,
210 21,
211 11000,
212 124,
213 10000,
214 3711,
215 7600,
216 12,
217 131,
218 132,
219 1731,
220 200,
221 300,
222 3100,
223 112,
224 12300,
225 8000,
226 141,
227 1441,
228 1600,
229 12600,
230 1421,
231 101,
232 111,
233 1711,
234 3000,
235 1000,
236 1100,
237 2100,
238 12800,
239 1500,
240 12400,
241 500,
242 3200,
243 7400,
244 1800,
245 122,
246 1722,
247 7100,
248 6300,
249 6700,
250 6400,
251 6500,
252 2400,
253 2410,
254 5700,
255 9200,
256 9300,
257 22,
258 501,
259 5800,
260 8100,
261 8500,
262 7200,
263 9900,
264 7700,
265 7800,
266 10300,
267 8600,
268 8700,
269 9100,
270 133,
271 11600,
272 12500,
273 13000,
274 13200,
275 13300,
276 6211,
277 6221,
278 6231,
279 6241,
280 8800,
281 12900,
282 12200,
283 9700,
284 9710,
285 9800,
286 9810,
287 9400,
288 9500,
289 9600,
290 10400,
291 10410,
292 10500,
293 10600,
294 10700,
295 9000,
296 5200,
297 6800,
298 6600,
299 8200,
300 11300,
301 12700
302 };
303
304 /**
305 * types
306 */
307
308 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
309
310 /**
311 * globals
312 */
313
314 static unsigned int full01 = 0x01010101;
315 static unsigned int full80 = 0x80808080;
316
317 int SUPPRESS_OUTPUT = 0;
318
319 hc_thread_mutex_t mux_adl;
320 hc_thread_mutex_t mux_counter;
321 hc_thread_mutex_t mux_dispatcher;
322 hc_thread_mutex_t mux_display;
323
324 hc_global_data_t data;
325
326 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
327
328 const char *USAGE_MINI[] =
329 {
330 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
331 "",
332 "Try --help for more help.",
333 NULL
334 };
335
336 const char *USAGE_BIG[] =
337 {
338 "%s, advanced password recovery",
339 "",
340 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
341 "",
342 "=======",
343 "Options",
344 "=======",
345 "",
346 "* General:",
347 "",
348 " -m, --hash-type=NUM Hash-type, see references below",
349 " -a, --attack-mode=NUM Attack-mode, see references below",
350 " -V, --version Print version",
351 " -h, --help Print help",
352 " --quiet Suppress output",
353 "",
354 "* Misc:",
355 "",
356 " --hex-charset Assume charset is given in hex",
357 " --hex-salt Assume salt is given in hex",
358 " --hex-wordlist Assume words in wordlist is given in hex",
359 " --force Ignore warnings",
360 " --status Enable automatic update of the status-screen",
361 " --status-timer=NUM Seconds between status-screen update",
362 " --status-automat Display the status view in a machine readable format",
363 " --loopback Add new plains to induct directory",
364 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
365 "",
366 "* Markov:",
367 "",
368 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
369 " --markov-disable Disables markov-chains, emulates classic brute-force",
370 " --markov-classic Enables classic markov-chains, no per-position enhancement",
371 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
372 "",
373 "* Session:",
374 "",
375 " --runtime=NUM Abort session after NUM seconds of runtime",
376 " --session=STR Define specific session name",
377 " --restore Restore session from --session",
378 " --restore-disable Do not write restore file",
379 "",
380 "* Files:",
381 "",
382 " -o, --outfile=FILE Define outfile for recovered hash",
383 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
384 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
385 " --outfile-check-timer=NUM Seconds between outfile checks",
386 " -p, --separator=CHAR Separator char for hashlists and outfile",
387 " --show Show cracked passwords only",
388 " --left Show un-cracked passwords only",
389 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
390 " --remove Enable remove of hash once it is cracked",
391 " --remove-timer=NUM Update input hash file each NUM seconds",
392 " --potfile-disable Do not write potfile",
393 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
394 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
395 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
396 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
397 " --logfile-disable Disable the logfile",
398 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
399 "",
400 "* Resources:",
401 "",
402 " -b, --benchmark Run benchmark",
403 " --benchmark-repeats=NUM Repeat the kernel on the device NUM times to increase benchmark accuracy",
404 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
405 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
406 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
407 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
408 " --opencl-platforms=STR OpenCL platforms to use, separate with comma",
409 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
410 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
411 " --opencl-vector-width=NUM OpenCL vector-width (either 1, 2, 4, 8 or 16), overrides value from device query",
412 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
413 " -n, --kernel-accel=NUM Workload tuning, increase the outer-loop step size",
414 " -u, --kernel-loops=NUM Workload tuning, increase the inner-loop step size",
415 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
416 #ifdef HAVE_HWMON
417 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
418 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
419 #ifdef HAVE_ADL
420 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
421 #endif
422 #endif
423 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
424 "",
425 "* Distributed:",
426 "",
427 " -s, --skip=NUM Skip number of words",
428 " -l, --limit=NUM Limit number of words",
429 " --keyspace Show keyspace base:mod values and quit",
430 "",
431 "* Rules:",
432 "",
433 " -j, --rule-left=RULE Single rule applied to each word from left dict",
434 " -k, --rule-right=RULE Single rule applied to each word from right dict",
435 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
436 " -g, --generate-rules=NUM Generate NUM random rules",
437 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
438 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
439 " --generate-rules-seed=NUM Force RNG seed to NUM",
440 "",
441 "* Custom charsets:",
442 "",
443 " -1, --custom-charset1=CS User-defined charsets",
444 " -2, --custom-charset2=CS Example:",
445 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
446 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
447 "",
448 "* Increment:",
449 "",
450 " -i, --increment Enable increment mode",
451 " --increment-min=NUM Start incrementing at NUM",
452 " --increment-max=NUM Stop incrementing at NUM",
453 "",
454 "==========",
455 "References",
456 "==========",
457 "",
458 "* Workload Profile:",
459 "",
460 " 1 = Interactive performance profile, kernel execution runtime to 8ms, lower latency desktop, lower speed",
461 " 2 = Default performance profile, kernel execution runtime to 16ms, economic setting",
462 " 3 = Headless performance profile, kernel execution runtime to 96ms, higher latency desktop, higher speed",
463 "",
464 "* OpenCL device-types:",
465 "",
466 " 1 = CPU devices",
467 " 2 = GPU devices",
468 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
469 "",
470 "* Outfile Formats:",
471 "",
472 " 1 = hash[:salt]",
473 " 2 = plain",
474 " 3 = hash[:salt]:plain",
475 " 4 = hex_plain",
476 " 5 = hash[:salt]:hex_plain",
477 " 6 = plain:hex_plain",
478 " 7 = hash[:salt]:plain:hex_plain",
479 " 8 = crackpos",
480 " 9 = hash[:salt]:crackpos",
481 " 10 = plain:crackpos",
482 " 11 = hash[:salt]:plain:crackpos",
483 " 12 = hex_plain:crackpos",
484 " 13 = hash[:salt]:hex_plain:crackpos",
485 " 14 = plain:hex_plain:crackpos",
486 " 15 = hash[:salt]:plain:hex_plain:crackpos",
487 "",
488 "* Debug mode output formats (for hybrid mode only, by using rules):",
489 "",
490 " 1 = save finding rule",
491 " 2 = save original word",
492 " 3 = save original word and finding rule",
493 " 4 = save original word, finding rule and modified plain",
494 "",
495 "* Built-in charsets:",
496 "",
497 " ?l = abcdefghijklmnopqrstuvwxyz",
498 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
499 " ?d = 0123456789",
500 " ?s = !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
501 " ?a = ?l?u?d?s",
502 " ?b = 0x00 - 0xff",
503 "",
504 "* Attack modes:",
505 "",
506 " 0 = Straight",
507 " 1 = Combination",
508 " 3 = Brute-force",
509 " 6 = Hybrid dict + mask",
510 " 7 = Hybrid mask + dict",
511 "",
512 "* Hash types:",
513 "",
514 "[[ Roll-your-own: Raw Hashes ]]",
515 "",
516 " 900 = MD4",
517 " 0 = MD5",
518 " 5100 = Half MD5",
519 " 100 = SHA1",
520 " 10800 = SHA-384",
521 " 1400 = SHA-256",
522 " 1700 = SHA-512",
523 " 5000 = SHA-3(Keccak)",
524 " 10100 = SipHash",
525 " 6000 = RipeMD160",
526 " 6100 = Whirlpool",
527 " 6900 = GOST R 34.11-94",
528 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
529 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
530 "",
531 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
532 "",
533 " 10 = md5($pass.$salt)",
534 " 20 = md5($salt.$pass)",
535 " 30 = md5(unicode($pass).$salt)",
536 " 40 = md5($salt.unicode($pass))",
537 " 3800 = md5($salt.$pass.$salt)",
538 " 3710 = md5($salt.md5($pass))",
539 " 2600 = md5(md5($pass)",
540 " 4300 = md5(strtoupper(md5($pass)))",
541 " 4400 = md5(sha1($pass))",
542 " 110 = sha1($pass.$salt)",
543 " 120 = sha1($salt.$pass)",
544 " 130 = sha1(unicode($pass).$salt)",
545 " 140 = sha1($salt.unicode($pass))",
546 " 4500 = sha1(sha1($pass)",
547 " 4700 = sha1(md5($pass))",
548 " 4900 = sha1($salt.$pass.$salt)",
549 " 1410 = sha256($pass.$salt)",
550 " 1420 = sha256($salt.$pass)",
551 " 1430 = sha256(unicode($pass).$salt)",
552 " 1440 = sha256($salt.unicode($pass))",
553 " 1710 = sha512($pass.$salt)",
554 " 1720 = sha512($salt.$pass)",
555 " 1730 = sha512(unicode($pass).$salt)",
556 " 1740 = sha512($salt.unicode($pass))",
557 "",
558 "[[ Roll-your-own: Authenticated Hashes ]]",
559 "",
560 " 50 = HMAC-MD5 (key = $pass)",
561 " 60 = HMAC-MD5 (key = $salt)",
562 " 150 = HMAC-SHA1 (key = $pass)",
563 " 160 = HMAC-SHA1 (key = $salt)",
564 " 1450 = HMAC-SHA256 (key = $pass)",
565 " 1460 = HMAC-SHA256 (key = $salt)",
566 " 1750 = HMAC-SHA512 (key = $pass)",
567 " 1760 = HMAC-SHA512 (key = $salt)",
568 "",
569 "[[ Generic KDF ]]",
570 "",
571 " 400 = phpass",
572 " 8900 = scrypt",
573 " 11900 = PBKDF2-HMAC-MD5",
574 " 12000 = PBKDF2-HMAC-SHA1",
575 " 10900 = PBKDF2-HMAC-SHA256",
576 " 12100 = PBKDF2-HMAC-SHA512",
577 "",
578 "[[ Network protocols, Challenge-Response ]]",
579 "",
580 " 23 = Skype",
581 " 2500 = WPA/WPA2",
582 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
583 " 5300 = IKE-PSK MD5",
584 " 5400 = IKE-PSK SHA1",
585 " 5500 = NetNTLMv1",
586 " 5500 = NetNTLMv1 + ESS",
587 " 5600 = NetNTLMv2",
588 " 7300 = IPMI2 RAKP HMAC-SHA1",
589 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
590 " 8300 = DNSSEC (NSEC3)",
591 " 10200 = Cram MD5",
592 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
593 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
594 " 11400 = SIP digest authentication (MD5)",
595 " 13100 = Kerberos 5 TGS-REP etype 23",
596 "",
597 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
598 "",
599 " 121 = SMF (Simple Machines Forum)",
600 " 400 = phpBB3",
601 " 2611 = vBulletin < v3.8.5",
602 " 2711 = vBulletin > v3.8.5",
603 " 2811 = MyBB",
604 " 2811 = IPB (Invison Power Board)",
605 " 8400 = WBB3 (Woltlab Burning Board)",
606 " 11 = Joomla < 2.5.18",
607 " 400 = Joomla > 2.5.18",
608 " 400 = Wordpress",
609 " 2612 = PHPS",
610 " 7900 = Drupal7",
611 " 21 = osCommerce",
612 " 21 = xt:Commerce",
613 " 11000 = PrestaShop",
614 " 124 = Django (SHA-1)",
615 " 10000 = Django (PBKDF2-SHA256)",
616 " 3711 = Mediawiki B type",
617 " 7600 = Redmine",
618 "",
619 "[[ Database Server ]]",
620 "",
621 " 12 = PostgreSQL",
622 " 131 = MSSQL(2000)",
623 " 132 = MSSQL(2005)",
624 " 1731 = MSSQL(2012)",
625 " 1731 = MSSQL(2014)",
626 " 200 = MySQL323",
627 " 300 = MySQL4.1/MySQL5",
628 " 3100 = Oracle H: Type (Oracle 7+)",
629 " 112 = Oracle S: Type (Oracle 11+)",
630 " 12300 = Oracle T: Type (Oracle 12+)",
631 " 8000 = Sybase ASE",
632 "",
633 "[[ HTTP, SMTP, LDAP Server ]]",
634 "",
635 " 141 = EPiServer 6.x < v4",
636 " 1441 = EPiServer 6.x > v4",
637 " 1600 = Apache $apr1$",
638 " 12600 = ColdFusion 10+",
639 " 1421 = hMailServer",
640 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
641 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
642 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
643 "",
644 "[[ Checksums ]]",
645 "",
646 " 11500 = CRC32",
647 "",
648 "[[ Operating-Systems ]]",
649 "",
650 " 3000 = LM",
651 " 1000 = NTLM",
652 " 1100 = Domain Cached Credentials (DCC), MS Cache",
653 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
654 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
655 " 1500 = descrypt, DES(Unix), Traditional DES",
656 " 12400 = BSDiCrypt, Extended DES",
657 " 500 = md5crypt $1$, MD5(Unix)",
658 " 3200 = bcrypt $2*$, Blowfish(Unix)",
659 " 7400 = sha256crypt $5$, SHA256(Unix)",
660 " 1800 = sha512crypt $6$, SHA512(Unix)",
661 " 122 = OSX v10.4",
662 " 122 = OSX v10.5",
663 " 122 = OSX v10.6",
664 " 1722 = OSX v10.7",
665 " 7100 = OSX v10.8",
666 " 7100 = OSX v10.9",
667 " 7100 = OSX v10.10",
668 " 6300 = AIX {smd5}",
669 " 6700 = AIX {ssha1}",
670 " 6400 = AIX {ssha256}",
671 " 6500 = AIX {ssha512}",
672 " 2400 = Cisco-PIX",
673 " 2410 = Cisco-ASA",
674 " 500 = Cisco-IOS $1$",
675 " 5700 = Cisco-IOS $4$",
676 " 9200 = Cisco-IOS $8$",
677 " 9300 = Cisco-IOS $9$",
678 " 22 = Juniper Netscreen/SSG (ScreenOS)",
679 " 501 = Juniper IVE",
680 " 5800 = Android PIN",
681 " 8100 = Citrix Netscaler",
682 " 8500 = RACF",
683 " 7200 = GRUB 2",
684 " 9900 = Radmin2",
685 "",
686 "[[ Enterprise Application Software (EAS) ]]",
687 "",
688 " 7700 = SAP CODVN B (BCODE)",
689 " 7800 = SAP CODVN F/G (PASSCODE)",
690 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
691 " 8600 = Lotus Notes/Domino 5",
692 " 8700 = Lotus Notes/Domino 6",
693 " 9100 = Lotus Notes/Domino 8",
694 " 133 = PeopleSoft",
695 "",
696 "[[ Archives ]]",
697 "",
698 " 11600 = 7-Zip",
699 " 12500 = RAR3-hp",
700 " 13000 = RAR5",
701 " 13200 = AxCrypt",
702 " 13300 = AxCrypt in memory SHA1",
703 "",
704 "[[ Full-Disk encryptions (FDE) ]]",
705 "",
706 " 62XY = TrueCrypt 5.0+",
707 " X = 1 = PBKDF2-HMAC-RipeMD160",
708 " X = 2 = PBKDF2-HMAC-SHA512",
709 " X = 3 = PBKDF2-HMAC-Whirlpool",
710 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
711 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
712 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
713 " Y = 3 = XTS 1536 bit (Ciphers: All)",
714 " 8800 = Android FDE < v4.3",
715 " 12900 = Android FDE (Samsung DEK)",
716 " 12200 = eCryptfs",
717 "",
718 "[[ Documents ]]",
719 "",
720 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
721 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
722 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
723 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
724 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
725 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
726 " 9400 = MS Office 2007",
727 " 9500 = MS Office 2010",
728 " 9600 = MS Office 2013",
729 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
730 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
731 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
732 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
733 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
734 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
735 "",
736 "[[ Password Managers ]]",
737 "",
738 " 9000 = Password Safe v2",
739 " 5200 = Password Safe v3",
740 " 6800 = Lastpass",
741 " 6600 = 1Password, agilekeychain",
742 " 8200 = 1Password, cloudkeychain",
743 " 11300 = Bitcoin/Litecoin wallet.dat",
744 " 12700 = Blockchain, My Wallet",
745 "",
746 NULL
747 };
748
749 /**
750 * oclHashcat specific functions
751 */
752
753 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
754 {
755 int exec_pos = (int) device_param->exec_pos - last_num_entries;
756
757 if (exec_pos < 0) exec_pos += EXEC_CACHE;
758
759 double exec_ms_sum = 0;
760
761 int exec_ms_cnt = 0;
762
763 for (int i = 0; i < last_num_entries; i++)
764 {
765 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
766
767 if (exec_ms)
768 {
769 exec_ms_sum += exec_ms;
770
771 exec_ms_cnt++;
772 }
773 }
774
775 if (exec_ms_cnt == 0) return 0;
776
777 return exec_ms_sum / exec_ms_cnt;
778 }
779
780 void status_display_automat ()
781 {
782 FILE *out = stdout;
783
784 fprintf (out, "STATUS\t%u\t", data.devices_status);
785
786 /**
787 * speed new
788 */
789
790 fprintf (out, "SPEED\t");
791
792 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
793 {
794 hc_device_param_t *device_param = &data.devices_param[device_id];
795
796 if (device_param->skipped) continue;
797
798 u64 speed_cnt = 0;
799 float speed_ms = 0;
800
801 for (int i = 0; i < SPEED_CACHE; i++)
802 {
803 float rec_ms;
804
805 hc_timer_get (device_param->speed_rec[i], rec_ms);
806
807 if (rec_ms > SPEED_MAXAGE) continue;
808
809 speed_cnt += device_param->speed_cnt[i];
810 speed_ms += device_param->speed_ms[i];
811 }
812
813 speed_cnt /= SPEED_CACHE;
814 speed_ms /= SPEED_CACHE;
815
816 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
817 }
818
819 /**
820 * exec time
821 */
822
823 fprintf (out, "EXEC_RUNTIME\t");
824
825 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
826 {
827 hc_device_param_t *device_param = &data.devices_param[device_id];
828
829 if (device_param->skipped) continue;
830
831 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
832
833 fprintf (out, "%f\t", exec_ms_avg);
834 }
835
836 /**
837 * words_cur
838 */
839
840 u64 words_cur = get_lowest_words_done ();
841
842 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
843
844 /**
845 * counter
846 */
847
848 u64 progress_total = data.words_cnt * data.salts_cnt;
849
850 u64 all_done = 0;
851 u64 all_rejected = 0;
852 u64 all_restored = 0;
853
854 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
855 {
856 all_done += data.words_progress_done[salt_pos];
857 all_rejected += data.words_progress_rejected[salt_pos];
858 all_restored += data.words_progress_restored[salt_pos];
859 }
860
861 u64 progress_cur = all_restored + all_done + all_rejected;
862 u64 progress_end = progress_total;
863
864 u64 progress_skip = 0;
865
866 if (data.skip)
867 {
868 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
869
870 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
871 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
872 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
873 }
874
875 if (data.limit)
876 {
877 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
878
879 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
880 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
881 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
882 }
883
884 u64 progress_cur_relative_skip = progress_cur - progress_skip;
885 u64 progress_end_relative_skip = progress_end - progress_skip;
886
887 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
888
889 /**
890 * cracks
891 */
892
893 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
894 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
895
896 /**
897 * temperature
898 */
899
900 #ifdef HAVE_HWMON
901 if (data.gpu_temp_disable == 0)
902 {
903 fprintf (out, "TEMP\t");
904
905 hc_thread_mutex_lock (mux_adl);
906
907 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
908 {
909 hc_device_param_t *device_param = &data.devices_param[device_id];
910
911 if (device_param->skipped) continue;
912
913 int temp = hm_get_temperature_with_device_id (device_id);
914
915 fprintf (out, "%d\t", temp);
916 }
917
918 hc_thread_mutex_unlock (mux_adl);
919 }
920 #endif // HAVE_HWMON
921
922 /**
923 * flush
924 */
925
926 #ifdef _WIN
927 fputc ('\r', out);
928 fputc ('\n', out);
929 #endif
930
931 #ifdef _POSIX
932 fputc ('\n', out);
933 #endif
934
935 fflush (out);
936 }
937
938 void status_display ()
939 {
940 if (data.devices_status == STATUS_INIT) return;
941 if (data.devices_status == STATUS_STARTING) return;
942 if (data.devices_status == STATUS_BYPASS) return;
943
944 if (data.status_automat == 1)
945 {
946 status_display_automat ();
947
948 return;
949 }
950
951 char tmp_buf[1000] = { 0 };
952
953 uint tmp_len = 0;
954
955 log_info ("Session.Name...: %s", data.session);
956
957 char *status_type = strstatus (data.devices_status);
958
959 uint hash_mode = data.hash_mode;
960
961 char *hash_type = strhashtype (hash_mode); // not a bug
962
963 log_info ("Status.........: %s", status_type);
964
965 /**
966 * show rules
967 */
968
969 if (data.rp_files_cnt)
970 {
971 uint i;
972
973 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
974 {
975 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
976 }
977
978 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
979
980 log_info ("Rules.Type.....: %s", tmp_buf);
981
982 tmp_len = 0;
983 }
984
985 if (data.rp_gen)
986 {
987 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
988
989 if (data.rp_gen_seed)
990 {
991 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
992 }
993 }
994
995 /**
996 * show input
997 */
998
999 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1000 {
1001 if (data.wordlist_mode == WL_MODE_FILE)
1002 {
1003 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
1004 }
1005 else if (data.wordlist_mode == WL_MODE_STDIN)
1006 {
1007 log_info ("Input.Mode.....: Pipe");
1008 }
1009 }
1010 else if (data.attack_mode == ATTACK_MODE_COMBI)
1011 {
1012 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1013 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1014 }
1015 else if (data.attack_mode == ATTACK_MODE_BF)
1016 {
1017 char *mask = data.mask;
1018
1019 if (mask != NULL)
1020 {
1021 uint mask_len = data.css_cnt;
1022
1023 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1024
1025 if (mask_len > 0)
1026 {
1027 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1028 {
1029 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1030 {
1031 mask_len -= data.salts_buf[0].salt_len;
1032 }
1033 }
1034
1035 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1036
1037 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1038 }
1039
1040 if (data.maskcnt > 1)
1041 {
1042 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1043
1044 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1045 }
1046
1047 log_info ("Input.Mode.....: %s", tmp_buf);
1048 }
1049
1050 tmp_len = 0;
1051 }
1052 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1053 {
1054 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1055 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1056 }
1057 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1058 {
1059 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1060 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1061 }
1062
1063 if (data.digests_cnt == 1)
1064 {
1065 if (data.hash_mode == 2500)
1066 {
1067 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1068
1069 uint pke[25] = { 0 };
1070
1071 char *pke_ptr = (char *) pke;
1072
1073 for (uint i = 0; i < 25; i++)
1074 {
1075 pke[i] = byte_swap_32 (wpa->pke[i]);
1076 }
1077
1078 char mac1[6] = { 0 };
1079 char mac2[6] = { 0 };
1080
1081 memcpy (mac1, pke_ptr + 23, 6);
1082 memcpy (mac2, pke_ptr + 29, 6);
1083
1084 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1085 (char *) data.salts_buf[0].salt_buf,
1086 mac1[0] & 0xff,
1087 mac1[1] & 0xff,
1088 mac1[2] & 0xff,
1089 mac1[3] & 0xff,
1090 mac1[4] & 0xff,
1091 mac1[5] & 0xff,
1092 mac2[0] & 0xff,
1093 mac2[1] & 0xff,
1094 mac2[2] & 0xff,
1095 mac2[3] & 0xff,
1096 mac2[4] & 0xff,
1097 mac2[5] & 0xff);
1098 }
1099 else if (data.hash_mode == 5200)
1100 {
1101 log_info ("Hash.Target....: File (%s)", data.hashfile);
1102 }
1103 else if (data.hash_mode == 9000)
1104 {
1105 log_info ("Hash.Target....: File (%s)", data.hashfile);
1106 }
1107 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1108 {
1109 log_info ("Hash.Target....: File (%s)", data.hashfile);
1110 }
1111 else
1112 {
1113 char out_buf[4096] = { 0 };
1114
1115 ascii_digest (out_buf, 0, 0);
1116
1117 // limit length
1118 if (strlen (out_buf) > 40)
1119 {
1120 out_buf[41] = '.';
1121 out_buf[42] = '.';
1122 out_buf[43] = '.';
1123 out_buf[44] = 0;
1124 }
1125
1126 log_info ("Hash.Target....: %s", out_buf);
1127 }
1128 }
1129 else
1130 {
1131 if (data.hash_mode == 3000)
1132 {
1133 char out_buf1[4096] = { 0 };
1134 char out_buf2[4096] = { 0 };
1135
1136 ascii_digest (out_buf1, 0, 0);
1137 ascii_digest (out_buf2, 0, 1);
1138
1139 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1140 }
1141 else
1142 {
1143 log_info ("Hash.Target....: File (%s)", data.hashfile);
1144 }
1145 }
1146
1147 log_info ("Hash.Type......: %s", hash_type);
1148
1149 /**
1150 * speed new
1151 */
1152
1153 u64 speed_cnt[DEVICES_MAX] = { 0 };
1154 float speed_ms[DEVICES_MAX] = { 0 };
1155
1156 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1157 {
1158 hc_device_param_t *device_param = &data.devices_param[device_id];
1159
1160 if (device_param->skipped) continue;
1161
1162 // we need to clear values (set to 0) because in case the device does
1163 // not get new candidates it idles around but speed display would
1164 // show it as working.
1165 // if we instantly set it to 0 after reading it happens that the
1166 // speed can be shown as zero if the users refreshes too fast.
1167 // therefore, we add a timestamp when a stat was recorded and if its
1168 // too old we will not use it
1169
1170 speed_cnt[device_id] = 0;
1171 speed_ms[device_id] = 0;
1172
1173 for (int i = 0; i < SPEED_CACHE; i++)
1174 {
1175 float rec_ms;
1176
1177 hc_timer_get (device_param->speed_rec[i], rec_ms);
1178
1179 if (rec_ms > SPEED_MAXAGE) continue;
1180
1181 speed_cnt[device_id] += device_param->speed_cnt[i];
1182 speed_ms[device_id] += device_param->speed_ms[i];
1183 }
1184
1185 speed_cnt[device_id] /= SPEED_CACHE;
1186 speed_ms[device_id] /= SPEED_CACHE;
1187 }
1188
1189 float hashes_all_ms = 0;
1190
1191 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1192
1193 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1194 {
1195 hc_device_param_t *device_param = &data.devices_param[device_id];
1196
1197 if (device_param->skipped) continue;
1198
1199 hashes_dev_ms[device_id] = 0;
1200
1201 if (speed_ms[device_id])
1202 {
1203 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1204
1205 hashes_all_ms += hashes_dev_ms[device_id];
1206 }
1207 }
1208
1209 /**
1210 * exec time
1211 */
1212
1213 double exec_all_ms[DEVICES_MAX] = { 0 };
1214
1215 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1216 {
1217 hc_device_param_t *device_param = &data.devices_param[device_id];
1218
1219 if (device_param->skipped) continue;
1220
1221 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1222
1223 exec_all_ms[device_id] = exec_ms_avg;
1224 }
1225
1226 /**
1227 * timers
1228 */
1229
1230 float ms_running = 0;
1231
1232 hc_timer_get (data.timer_running, ms_running);
1233
1234 float ms_paused = data.ms_paused;
1235
1236 if (data.devices_status == STATUS_PAUSED)
1237 {
1238 float ms_paused_tmp = 0;
1239
1240 hc_timer_get (data.timer_paused, ms_paused_tmp);
1241
1242 ms_paused += ms_paused_tmp;
1243 }
1244
1245 #ifdef WIN
1246
1247 __time64_t sec_run = ms_running / 1000;
1248
1249 #else
1250
1251 time_t sec_run = ms_running / 1000;
1252
1253 #endif
1254
1255 if (sec_run)
1256 {
1257 char display_run[32] = { 0 };
1258
1259 struct tm tm_run;
1260
1261 struct tm *tmp = NULL;
1262
1263 #ifdef WIN
1264
1265 tmp = _gmtime64 (&sec_run);
1266
1267 #else
1268
1269 tmp = gmtime (&sec_run);
1270
1271 #endif
1272
1273 if (tmp != NULL)
1274 {
1275 memset (&tm_run, 0, sizeof (tm_run));
1276
1277 memcpy (&tm_run, tmp, sizeof (tm_run));
1278
1279 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1280
1281 char *start = ctime (&data.proc_start);
1282
1283 size_t start_len = strlen (start);
1284
1285 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1286 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1287
1288 log_info ("Time.Started...: %s (%s)", start, display_run);
1289 }
1290 }
1291 else
1292 {
1293 log_info ("Time.Started...: 0 secs");
1294 }
1295
1296 /**
1297 * counters
1298 */
1299
1300 u64 progress_total = data.words_cnt * data.salts_cnt;
1301
1302 u64 all_done = 0;
1303 u64 all_rejected = 0;
1304 u64 all_restored = 0;
1305
1306 u64 progress_noneed = 0;
1307
1308 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1309 {
1310 all_done += data.words_progress_done[salt_pos];
1311 all_rejected += data.words_progress_rejected[salt_pos];
1312 all_restored += data.words_progress_restored[salt_pos];
1313
1314 // Important for ETA only
1315
1316 if (data.salts_shown[salt_pos] == 1)
1317 {
1318 const u64 all = data.words_progress_done[salt_pos]
1319 + data.words_progress_rejected[salt_pos]
1320 + data.words_progress_restored[salt_pos];
1321
1322 const u64 left = data.words_cnt - all;
1323
1324 progress_noneed += left;
1325 }
1326 }
1327
1328 u64 progress_cur = all_restored + all_done + all_rejected;
1329 u64 progress_end = progress_total;
1330
1331 u64 progress_skip = 0;
1332
1333 if (data.skip)
1334 {
1335 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1336
1337 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1338 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1339 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1340 }
1341
1342 if (data.limit)
1343 {
1344 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1345
1346 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1347 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1348 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1349 }
1350
1351 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1352 u64 progress_end_relative_skip = progress_end - progress_skip;
1353
1354 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1355 {
1356 if (data.devices_status != STATUS_CRACKED)
1357 {
1358 #ifdef WIN
1359 __time64_t sec_etc = 0;
1360 #else
1361 time_t sec_etc = 0;
1362 #endif
1363
1364 if (hashes_all_ms)
1365 {
1366 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1367
1368 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1369
1370 sec_etc = ms_left / 1000;
1371 }
1372
1373 if (sec_etc == 0)
1374 {
1375 //log_info ("Time.Estimated.: 0 secs");
1376 }
1377 else if ((u64) sec_etc > ETC_MAX)
1378 {
1379 log_info ("Time.Estimated.: > 10 Years");
1380 }
1381 else
1382 {
1383 char display_etc[32] = { 0 };
1384
1385 struct tm tm_etc;
1386
1387 struct tm *tmp = NULL;
1388
1389 #ifdef WIN
1390
1391 tmp = _gmtime64 (&sec_etc);
1392
1393 #else
1394
1395 tmp = gmtime (&sec_etc);
1396
1397 #endif
1398
1399 if (tmp != NULL)
1400 {
1401 memset (&tm_etc, 0, sizeof (tm_etc));
1402
1403 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1404
1405 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1406
1407 time_t now;
1408
1409 time (&now);
1410
1411 now += sec_etc;
1412
1413 char *etc = ctime (&now);
1414
1415 size_t etc_len = strlen (etc);
1416
1417 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1418 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1419
1420 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1421 }
1422 }
1423 }
1424 }
1425
1426 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1427 {
1428 hc_device_param_t *device_param = &data.devices_param[device_id];
1429
1430 if (device_param->skipped) continue;
1431
1432 char display_dev_cur[16] = { 0 };
1433
1434 strncpy (display_dev_cur, "0.00", 4);
1435
1436 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1437
1438 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1439 }
1440
1441 char display_all_cur[16] = { 0 };
1442
1443 strncpy (display_all_cur, "0.00", 4);
1444
1445 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1446
1447 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1448
1449 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1450 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1451
1452 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);
1453
1454 // crack-per-time
1455
1456 if (data.digests_cnt > 100)
1457 {
1458 time_t now = time (NULL);
1459
1460 int cpt_cur_min = 0;
1461 int cpt_cur_hour = 0;
1462 int cpt_cur_day = 0;
1463
1464 for (int i = 0; i < CPT_BUF; i++)
1465 {
1466 const uint cracked = data.cpt_buf[i].cracked;
1467 const time_t timestamp = data.cpt_buf[i].timestamp;
1468
1469 if ((timestamp + 60) > now)
1470 {
1471 cpt_cur_min += cracked;
1472 }
1473
1474 if ((timestamp + 3600) > now)
1475 {
1476 cpt_cur_hour += cracked;
1477 }
1478
1479 if ((timestamp + 86400) > now)
1480 {
1481 cpt_cur_day += cracked;
1482 }
1483 }
1484
1485 float ms_real = ms_running - ms_paused;
1486
1487 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1488 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1489 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1490
1491 if ((data.cpt_start + 86400) < now)
1492 {
1493 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1494 cpt_cur_min,
1495 cpt_cur_hour,
1496 cpt_cur_day,
1497 cpt_avg_min,
1498 cpt_avg_hour,
1499 cpt_avg_day);
1500 }
1501 else if ((data.cpt_start + 3600) < now)
1502 {
1503 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1504 cpt_cur_min,
1505 cpt_cur_hour,
1506 cpt_avg_min,
1507 cpt_avg_hour,
1508 cpt_avg_day);
1509 }
1510 else if ((data.cpt_start + 60) < now)
1511 {
1512 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1513 cpt_cur_min,
1514 cpt_avg_min,
1515 cpt_avg_hour,
1516 cpt_avg_day);
1517 }
1518 else
1519 {
1520 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1521 cpt_avg_min,
1522 cpt_avg_hour,
1523 cpt_avg_day);
1524 }
1525 }
1526
1527 // Restore point
1528
1529 u64 restore_point = get_lowest_words_done ();
1530
1531 u64 restore_total = data.words_base;
1532
1533 float percent_restore = 0;
1534
1535 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1536
1537 if (progress_end_relative_skip)
1538 {
1539 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1540 {
1541 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1542 float percent_rejected = 0.0;
1543
1544 if (progress_cur)
1545 {
1546 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1547 }
1548
1549 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);
1550 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1551
1552 if (data.restore_disable == 0)
1553 {
1554 if (percent_finished != 1)
1555 {
1556 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1557 }
1558 }
1559 }
1560 }
1561 else
1562 {
1563 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1564 {
1565 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1566 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1567
1568 if (data.restore_disable == 0)
1569 {
1570 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1571 }
1572 }
1573 else
1574 {
1575 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1576 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1577
1578 // --restore not allowed if stdin is used -- really? why?
1579
1580 //if (data.restore_disable == 0)
1581 //{
1582 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1583 //}
1584 }
1585 }
1586
1587 #ifdef HAVE_HWMON
1588 if (data.gpu_temp_disable == 0)
1589 {
1590 hc_thread_mutex_lock (mux_adl);
1591
1592 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1593 {
1594 hc_device_param_t *device_param = &data.devices_param[device_id];
1595
1596 if (device_param->skipped) continue;
1597
1598 #define HM_STR_BUF_SIZE 255
1599
1600 if (data.hm_device[device_id].fan_supported == 1)
1601 {
1602 char utilization[HM_STR_BUF_SIZE] = { 0 };
1603 char temperature[HM_STR_BUF_SIZE] = { 0 };
1604 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1605
1606 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1607 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1608
1609 if (device_param->vendor_id == VENDOR_ID_AMD)
1610 {
1611 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1612 }
1613 else if (device_param->vendor_id == VENDOR_ID_NV)
1614 {
1615 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1616 }
1617
1618 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1619 }
1620 else
1621 {
1622 char utilization[HM_STR_BUF_SIZE] = { 0 };
1623 char temperature[HM_STR_BUF_SIZE] = { 0 };
1624
1625 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1626 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1627
1628 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1629 }
1630 }
1631
1632 hc_thread_mutex_unlock (mux_adl);
1633 }
1634 #endif // HAVE_HWMON
1635 }
1636
1637 static void status_benchmark ()
1638 {
1639 if (data.devices_status == STATUS_INIT) return;
1640 if (data.devices_status == STATUS_STARTING) return;
1641
1642 if (data.words_cnt == 0) return;
1643
1644 u64 speed_cnt[DEVICES_MAX] = { 0 };
1645 float speed_ms[DEVICES_MAX] = { 0 };
1646
1647 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1648 {
1649 hc_device_param_t *device_param = &data.devices_param[device_id];
1650
1651 if (device_param->skipped) continue;
1652
1653 speed_cnt[device_id] = 0;
1654 speed_ms[device_id] = 0;
1655
1656 for (int i = 0; i < SPEED_CACHE; i++)
1657 {
1658 speed_cnt[device_id] += device_param->speed_cnt[i];
1659 speed_ms[device_id] += device_param->speed_ms[i];
1660 }
1661
1662 speed_cnt[device_id] /= SPEED_CACHE;
1663 speed_ms[device_id] /= SPEED_CACHE;
1664 }
1665
1666 float hashes_all_ms = 0;
1667
1668 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1669
1670 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1671 {
1672 hc_device_param_t *device_param = &data.devices_param[device_id];
1673
1674 if (device_param->skipped) continue;
1675
1676 hashes_dev_ms[device_id] = 0;
1677
1678 if (speed_ms[device_id])
1679 {
1680 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1681
1682 hashes_all_ms += hashes_dev_ms[device_id];
1683 }
1684 }
1685
1686 /**
1687 * exec time
1688 */
1689
1690 double exec_all_ms[DEVICES_MAX] = { 0 };
1691
1692 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1693 {
1694 hc_device_param_t *device_param = &data.devices_param[device_id];
1695
1696 if (device_param->skipped) continue;
1697
1698 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1699
1700 exec_all_ms[device_id] = exec_ms_avg;
1701 }
1702
1703 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1704 {
1705 hc_device_param_t *device_param = &data.devices_param[device_id];
1706
1707 if (device_param->skipped) continue;
1708
1709 char display_dev_cur[16] = { 0 };
1710
1711 strncpy (display_dev_cur, "0.00", 4);
1712
1713 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1714
1715 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1716 }
1717
1718 char display_all_cur[16] = { 0 };
1719
1720 strncpy (display_all_cur, "0.00", 4);
1721
1722 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1723
1724 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1725 }
1726
1727 /**
1728 * oclHashcat -only- functions
1729 */
1730
1731 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1732 {
1733 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1734 {
1735 if (attack_kern == ATTACK_KERN_STRAIGHT)
1736 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1737 else if (attack_kern == ATTACK_KERN_COMBI)
1738 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1739 else if (attack_kern == ATTACK_KERN_BF)
1740 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1741 }
1742 else
1743 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1744 }
1745
1746 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)
1747 {
1748 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1749 {
1750 if (attack_kern == ATTACK_KERN_STRAIGHT)
1751 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1752 else if (attack_kern == ATTACK_KERN_COMBI)
1753 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1754 else if (attack_kern == ATTACK_KERN_BF)
1755 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1756 }
1757 else
1758 {
1759 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1760 }
1761 }
1762
1763 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1764 {
1765 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1766 {
1767 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1768 }
1769 else
1770 {
1771 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1772 }
1773 }
1774
1775 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)
1776 {
1777 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1778 {
1779 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1780 }
1781 else
1782 {
1783 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1784 }
1785 }
1786
1787 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1788 {
1789 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1790 }
1791
1792 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1793 {
1794 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1795 }
1796
1797 static uint convert_from_hex (char *line_buf, const uint line_len)
1798 {
1799 if (line_len & 1) return (line_len); // not in hex
1800
1801 if (data.hex_wordlist == 1)
1802 {
1803 uint i;
1804 uint j;
1805
1806 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1807 {
1808 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1809 }
1810
1811 memset (line_buf + i, 0, line_len - i);
1812
1813 return (i);
1814 }
1815 else if (line_len >= 6) // $HEX[] = 6
1816 {
1817 if (line_buf[0] != '$') return (line_len);
1818 if (line_buf[1] != 'H') return (line_len);
1819 if (line_buf[2] != 'E') return (line_len);
1820 if (line_buf[3] != 'X') return (line_len);
1821 if (line_buf[4] != '[') return (line_len);
1822 if (line_buf[line_len - 1] != ']') return (line_len);
1823
1824 uint i;
1825 uint j;
1826
1827 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1828 {
1829 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1830 }
1831
1832 memset (line_buf + i, 0, line_len - i);
1833
1834 return (i);
1835 }
1836
1837 return (line_len);
1838 }
1839
1840 static void clear_prompt ()
1841 {
1842 fputc ('\r', stdout);
1843
1844 for (size_t i = 0; i < strlen (PROMPT); i++)
1845 {
1846 fputc (' ', stdout);
1847 }
1848
1849 fputc ('\r', stdout);
1850
1851 fflush (stdout);
1852 }
1853
1854 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1855 {
1856 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);
1857 }
1858
1859 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1860 {
1861 char *outfile = data.outfile;
1862 uint quiet = data.quiet;
1863 FILE *pot_fp = data.pot_fp;
1864 uint loopback = data.loopback;
1865 uint debug_mode = data.debug_mode;
1866 char *debug_file = data.debug_file;
1867
1868 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1869 int debug_rule_len = 0; // -1 error
1870 uint debug_plain_len = 0;
1871
1872 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1873
1874 // hash
1875
1876 char out_buf[4096] = { 0 };
1877
1878 ascii_digest (out_buf, salt_pos, digest_pos);
1879
1880 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1881
1882 // plain
1883
1884 plain_t plain;
1885
1886 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);
1887
1888 uint gidvid = plain.gidvid;
1889 uint il_pos = plain.il_pos;
1890
1891 u64 crackpos = device_param->words_off;
1892
1893 uint plain_buf[16] = { 0 };
1894
1895 u8 *plain_ptr = (u8 *) plain_buf;
1896 unsigned int plain_len = 0;
1897
1898 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1899 {
1900 u64 gidd = gidvid;
1901 u64 gidm = 0;
1902
1903 pw_t pw;
1904
1905 gidd_to_pw_t (device_param, gidd, &pw);
1906
1907 for (int i = 0, j = gidm; i < 16; i++, j++)
1908 {
1909 plain_buf[i] = pw.i[j];
1910 }
1911
1912 plain_len = pw.pw_len;
1913
1914 const uint off = device_param->innerloop_pos + il_pos;
1915
1916 if (debug_mode > 0)
1917 {
1918 debug_rule_len = 0;
1919
1920 // save rule
1921 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1922 {
1923 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1924
1925 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1926 }
1927
1928 // save plain
1929 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1930 {
1931 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1932
1933 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1934
1935 debug_plain_len = plain_len;
1936 }
1937 }
1938
1939 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1940
1941 crackpos += gidvid;
1942 crackpos *= data.kernel_rules_cnt;
1943 crackpos += device_param->innerloop_pos + il_pos;
1944
1945 if (plain_len > data.pw_max) plain_len = data.pw_max;
1946 }
1947 else if (data.attack_mode == ATTACK_MODE_COMBI)
1948 {
1949 u64 gidd = gidvid;
1950 u64 gidm = 0;
1951
1952 pw_t pw;
1953
1954 gidd_to_pw_t (device_param, gidd, &pw);
1955
1956 for (int i = 0, j = gidm; i < 16; i++, j++)
1957 {
1958 plain_buf[i] = pw.i[j];
1959 }
1960
1961 plain_len = pw.pw_len;
1962
1963 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1964 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1965
1966 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1967 {
1968 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1969 }
1970 else
1971 {
1972 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1973
1974 memcpy (plain_ptr, comb_buf, comb_len);
1975 }
1976
1977 plain_len += comb_len;
1978
1979 crackpos += gidvid;
1980 crackpos *= data.combs_cnt;
1981 crackpos += device_param->innerloop_pos + il_pos;
1982
1983 if (data.pw_max != PW_DICTMAX1)
1984 {
1985 if (plain_len > data.pw_max) plain_len = data.pw_max;
1986 }
1987 }
1988 else if (data.attack_mode == ATTACK_MODE_BF)
1989 {
1990 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1991 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1992
1993 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1994 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1995
1996 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1997 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1998
1999 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2000 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2001
2002 plain_len = data.css_cnt;
2003
2004 crackpos += gidvid;
2005 crackpos *= data.bfs_cnt;
2006 crackpos += device_param->innerloop_pos + il_pos;
2007 }
2008 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2009 {
2010 u64 gidd = gidvid;
2011 u64 gidm = 0;
2012
2013 pw_t pw;
2014
2015 gidd_to_pw_t (device_param, gidd, &pw);
2016
2017 for (int i = 0, j = gidm; i < 16; i++, j++)
2018 {
2019 plain_buf[i] = pw.i[j];
2020 }
2021
2022 plain_len = pw.pw_len;
2023
2024 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2025
2026 uint start = 0;
2027 uint stop = device_param->kernel_params_mp_buf32[4];
2028
2029 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2030
2031 plain_len += start + stop;
2032
2033 crackpos += gidvid;
2034 crackpos *= data.combs_cnt;
2035 crackpos += device_param->innerloop_pos + il_pos;
2036
2037 if (data.pw_max != PW_DICTMAX1)
2038 {
2039 if (plain_len > data.pw_max) plain_len = data.pw_max;
2040 }
2041 }
2042 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2043 {
2044 u64 gidd = gidvid;
2045 u64 gidm = 0;
2046
2047 pw_t pw;
2048
2049 gidd_to_pw_t (device_param, gidd, &pw);
2050
2051 for (int i = 0, j = gidm; i < 16; i++, j++)
2052 {
2053 plain_buf[i] = pw.i[j];
2054 }
2055
2056 plain_len = pw.pw_len;
2057
2058 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2059
2060 uint start = 0;
2061 uint stop = device_param->kernel_params_mp_buf32[4];
2062
2063 memmove (plain_ptr + stop, plain_ptr, plain_len);
2064
2065 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2066
2067 plain_len += start + stop;
2068
2069 crackpos += gidvid;
2070 crackpos *= data.combs_cnt;
2071 crackpos += device_param->innerloop_pos + il_pos;
2072
2073 if (data.pw_max != PW_DICTMAX1)
2074 {
2075 if (plain_len > data.pw_max) plain_len = data.pw_max;
2076 }
2077 }
2078
2079 if (data.attack_mode == ATTACK_MODE_BF)
2080 {
2081 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2082 {
2083 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2084 {
2085 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2086 {
2087 plain_len = plain_len - data.salts_buf[0].salt_len;
2088 }
2089 }
2090
2091 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2092 {
2093 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2094 {
2095 plain_ptr[j] = plain_ptr[i];
2096 }
2097
2098 plain_len = plain_len / 2;
2099 }
2100 }
2101 }
2102
2103 // if enabled, update also the potfile
2104
2105 if (pot_fp)
2106 {
2107 lock_file (pot_fp);
2108
2109 fprintf (pot_fp, "%s:", out_buf);
2110
2111 format_plain (pot_fp, plain_ptr, plain_len, 1);
2112
2113 fputc ('\n', pot_fp);
2114
2115 fflush (pot_fp);
2116
2117 unlock_file (pot_fp);
2118 }
2119
2120 // outfile
2121
2122 FILE *out_fp = NULL;
2123
2124 if (outfile != NULL)
2125 {
2126 if ((out_fp = fopen (outfile, "ab")) == NULL)
2127 {
2128 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2129
2130 out_fp = stdout;
2131 }
2132 lock_file (out_fp);
2133 }
2134 else
2135 {
2136 out_fp = stdout;
2137
2138 if (quiet == 0) clear_prompt ();
2139 }
2140
2141 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2142
2143 if (outfile != NULL)
2144 {
2145 if (out_fp != stdout)
2146 {
2147 fclose (out_fp);
2148 }
2149 }
2150 else
2151 {
2152 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2153 {
2154 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2155 {
2156 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2157 if (quiet == 0) fflush (stdout);
2158 }
2159 }
2160 }
2161
2162 // loopback
2163
2164 if (loopback)
2165 {
2166 char *loopback_file = data.loopback_file;
2167
2168 FILE *fb_fp = NULL;
2169
2170 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2171 {
2172 lock_file (fb_fp);
2173
2174 format_plain (fb_fp, plain_ptr, plain_len, 1);
2175
2176 fputc ('\n', fb_fp);
2177
2178 fclose (fb_fp);
2179 }
2180 }
2181
2182 // (rule) debug mode
2183
2184 // the next check implies that:
2185 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2186 // - debug_mode > 0
2187
2188 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2189 {
2190 if (debug_rule_len < 0) debug_rule_len = 0;
2191
2192 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2193
2194 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2195
2196 if ((quiet == 0) && (debug_file == NULL))
2197 {
2198 fprintf (stdout, "%s", PROMPT);
2199 fflush (stdout);
2200 }
2201 }
2202 }
2203
2204 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2205 {
2206 salt_t *salt_buf = &data.salts_buf[salt_pos];
2207
2208 int found = 0;
2209
2210 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);
2211
2212 for (uint i = 0; i < KERNEL_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2213
2214 if (found == 1)
2215 {
2216 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2217
2218 log_info_nn ("");
2219
2220 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);
2221
2222 uint cpt_cracked = 0;
2223
2224 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2225 {
2226 uint idx = salt_buf->digests_offset + digest_pos;
2227
2228 if (data.digests_shown_tmp[idx] == 0) continue;
2229
2230 if (data.digests_shown[idx] == 1) continue;
2231
2232 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2233 {
2234 data.digests_shown[idx] = 1;
2235
2236 data.digests_done++;
2237
2238 cpt_cracked++;
2239
2240 salt_buf->digests_done++;
2241
2242 if (salt_buf->digests_done == salt_buf->digests_cnt)
2243 {
2244 data.salts_shown[salt_pos] = 1;
2245
2246 data.salts_done++;
2247 }
2248 }
2249
2250 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2251
2252 check_hash (device_param, salt_pos, digest_pos);
2253 }
2254
2255 if (cpt_cracked > 0)
2256 {
2257 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2258 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2259
2260 data.cpt_pos++;
2261
2262 data.cpt_total += cpt_cracked;
2263
2264 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2265 }
2266
2267 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2268 {
2269 // we need to reset cracked state on the device
2270 // otherwise host thinks again and again the hash was cracked
2271 // and returns invalid password each time
2272
2273 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2274
2275 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);
2276 }
2277
2278 memset (device_param->result, 0, device_param->size_results);
2279
2280 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);
2281 }
2282 }
2283
2284 static void save_hash ()
2285 {
2286 char *hashfile = data.hashfile;
2287
2288 char new_hashfile[256] = { 0 };
2289 char old_hashfile[256] = { 0 };
2290
2291 snprintf (new_hashfile, 255, "%s.new", hashfile);
2292 snprintf (old_hashfile, 255, "%s.old", hashfile);
2293
2294 unlink (new_hashfile);
2295
2296 char separator = data.separator;
2297
2298 FILE *fp = fopen (new_hashfile, "wb");
2299
2300 if (fp == NULL)
2301 {
2302 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2303
2304 exit (-1);
2305 }
2306
2307 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2308 {
2309 if (data.salts_shown[salt_pos] == 1) continue;
2310
2311 salt_t *salt_buf = &data.salts_buf[salt_pos];
2312
2313 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2314 {
2315 uint idx = salt_buf->digests_offset + digest_pos;
2316
2317 if (data.digests_shown[idx] == 1) continue;
2318
2319 if (data.hash_mode != 2500)
2320 {
2321 char out_buf[4096] = { 0 };
2322
2323 if (data.username == 1)
2324 {
2325 user_t *user = data.hash_info[idx]->user;
2326
2327 uint i;
2328
2329 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2330
2331 fputc (separator, fp);
2332 }
2333
2334 ascii_digest (out_buf, salt_pos, digest_pos);
2335
2336 fputs (out_buf, fp);
2337
2338 log_out (fp, "");
2339 }
2340 else
2341 {
2342 hccap_t hccap;
2343
2344 to_hccap_t (&hccap, salt_pos, digest_pos);
2345
2346 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2347 }
2348 }
2349 }
2350
2351 fflush (fp);
2352
2353 fclose (fp);
2354
2355 unlink (old_hashfile);
2356
2357 if (rename (hashfile, old_hashfile) != 0)
2358 {
2359 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2360
2361 exit (-1);
2362 }
2363
2364 unlink (hashfile);
2365
2366 if (rename (new_hashfile, hashfile) != 0)
2367 {
2368 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2369
2370 exit (-1);
2371 }
2372
2373 unlink (old_hashfile);
2374 }
2375
2376 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2377 {
2378 // function called only in case kernel_power_all > words_left
2379
2380 float kernel_power_div = (float) (total_left) / kernel_power_all;
2381
2382 kernel_power_div += kernel_power_div / 100;
2383
2384 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2385
2386 while (kernel_power_new < total_left)
2387 {
2388 kernel_power_div += kernel_power_div / 100;
2389
2390 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2391 }
2392
2393 if (data.quiet == 0)
2394 {
2395 clear_prompt ();
2396
2397 log_info ("");
2398
2399 log_info ("INFO: approaching final keyspace, workload adjusted");
2400
2401 log_info ("");
2402
2403 fprintf (stdout, "%s", PROMPT);
2404
2405 fflush (stdout);
2406 }
2407
2408 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2409
2410 return kernel_power_div;
2411 }
2412
2413 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2414 {
2415 uint num_elements = num;
2416
2417 device_param->kernel_params_buf32[30] = data.combs_mode;
2418 device_param->kernel_params_buf32[31] = num;
2419
2420 uint kernel_threads = device_param->kernel_threads;
2421
2422 while (num_elements % kernel_threads) num_elements++;
2423
2424 cl_kernel kernel = NULL;
2425
2426 switch (kern_run)
2427 {
2428 case KERN_RUN_1: kernel = device_param->kernel1; break;
2429 case KERN_RUN_12: kernel = device_param->kernel12; break;
2430 case KERN_RUN_2: kernel = device_param->kernel2; break;
2431 case KERN_RUN_23: kernel = device_param->kernel23; break;
2432 case KERN_RUN_3: kernel = device_param->kernel3; break;
2433 }
2434
2435 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2436 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2437 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2438 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2439 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2440 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2441 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2442 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2443 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2444 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2445 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2446
2447 hc_timer_t timer;
2448
2449 hc_timer_set (&timer);
2450
2451 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2452 {
2453 const size_t global_work_size[3] = { num_elements, 32, 1 };
2454 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2455
2456 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2457 }
2458 else
2459 {
2460 size_t workgroup_size = 0;
2461
2462 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2463
2464 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2465
2466 const size_t global_work_size[3] = { num_elements, 1, 1 };
2467 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2468
2469 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2470 }
2471
2472 hc_clFlush (data.ocl, device_param->command_queue);
2473
2474 hc_clFinish (data.ocl, device_param->command_queue);
2475
2476 if (event_update)
2477 {
2478 float exec_time;
2479
2480 hc_timer_get (timer, exec_time);
2481
2482 uint exec_pos = device_param->exec_pos;
2483
2484 device_param->exec_ms[exec_pos] = exec_time;
2485
2486 exec_pos++;
2487
2488 if (exec_pos == EXEC_CACHE)
2489 {
2490 exec_pos = 0;
2491 }
2492
2493 device_param->exec_pos = exec_pos;
2494 }
2495 }
2496
2497 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2498 {
2499 uint num_elements = num;
2500
2501 switch (kern_run)
2502 {
2503 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2504 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2505 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2506 }
2507
2508 // causes problems with special threads like in bcrypt
2509 // const uint kernel_threads = device_param->kernel_threads;
2510
2511 uint kernel_threads = KERNEL_THREADS;
2512
2513 while (num_elements % kernel_threads) num_elements++;
2514
2515 cl_kernel kernel = NULL;
2516
2517 switch (kern_run)
2518 {
2519 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2520 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2521 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2522 }
2523
2524 switch (kern_run)
2525 {
2526 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2527 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2528 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2529 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2530 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2531 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2532 break;
2533 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2534 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2535 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2536 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2537 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2538 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2539 break;
2540 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2541 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2542 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2543 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2544 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2545 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2546 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2547 break;
2548 }
2549
2550 size_t workgroup_size = 0;
2551 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), &workgroup_size, NULL);
2552 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2553
2554 const size_t global_work_size[3] = { num_elements, 1, 1 };
2555 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2556
2557 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2558
2559 hc_clFlush (data.ocl, device_param->command_queue);
2560
2561 hc_clFinish (data.ocl, device_param->command_queue);
2562 }
2563
2564 static void run_kernel_tm (hc_device_param_t *device_param)
2565 {
2566 const uint num_elements = 1024; // fixed
2567
2568 uint kernel_threads = 32;
2569
2570 cl_kernel kernel = device_param->kernel_tm;
2571
2572 size_t workgroup_size = 0;
2573 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2574 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2575
2576 const size_t global_work_size[3] = { num_elements, 1, 1 };
2577 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2578
2579 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2580
2581 hc_clFlush (data.ocl, device_param->command_queue);
2582
2583 hc_clFinish (data.ocl, device_param->command_queue);
2584 }
2585
2586 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2587 {
2588 uint num_elements = num;
2589
2590 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2591 device_param->kernel_params_amp_buf32[6] = num_elements;
2592
2593 // causes problems with special threads like in bcrypt
2594 // const uint kernel_threads = device_param->kernel_threads;
2595
2596 uint kernel_threads = KERNEL_THREADS;
2597
2598 while (num_elements % kernel_threads) num_elements++;
2599
2600 cl_kernel kernel = device_param->kernel_amp;
2601
2602 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2603 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2604
2605 size_t workgroup_size = 0;
2606 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2607 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2608
2609 const size_t global_work_size[3] = { num_elements, 1, 1 };
2610 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2611
2612 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2613
2614 hc_clFlush (data.ocl, device_param->command_queue);
2615
2616 hc_clFinish (data.ocl, device_param->command_queue);
2617 }
2618
2619 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2620 {
2621 int rc = -1;
2622
2623 if (device_param->opencl_v12 && device_param->vendor_id == VENDOR_ID_AMD)
2624 {
2625 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2626
2627 const cl_uchar zero = 0;
2628
2629 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2630 }
2631
2632 if (rc != 0)
2633 {
2634 // NOTE: clEnqueueFillBuffer () always fails with -59
2635 // IOW, it's not supported by Nvidia ForceWare <= 352.21, also pocl segfaults, also on apple
2636 // How's that possible, OpenCL 1.2 support is advertised??
2637 // We need to workaround...
2638
2639 #define FILLSZ 0x100000
2640
2641 char *tmp = (char *) mymalloc (FILLSZ);
2642
2643 for (uint i = 0; i < size; i += FILLSZ)
2644 {
2645 const int left = size - i;
2646
2647 const int fillsz = MIN (FILLSZ, left);
2648
2649 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2650 }
2651
2652 myfree (tmp);
2653 }
2654 }
2655
2656 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)
2657 {
2658 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2659 {
2660 if (attack_mode == ATTACK_MODE_BF)
2661 {
2662 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2663 {
2664 const uint size_tm = 32 * sizeof (bs_word_t);
2665
2666 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2667
2668 run_kernel_tm (device_param);
2669
2670 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);
2671 }
2672 }
2673
2674 if (highest_pw_len < 16)
2675 {
2676 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2677 }
2678 else if (highest_pw_len < 32)
2679 {
2680 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2681 }
2682 else
2683 {
2684 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2685 }
2686 }
2687 else
2688 {
2689 run_kernel_amp (device_param, pws_cnt);
2690
2691 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2692
2693 if (opts_type & OPTS_TYPE_HOOK12)
2694 {
2695 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2696 }
2697
2698 uint iter = salt_buf->salt_iter;
2699
2700 uint loop_step = device_param->kernel_loops;
2701
2702 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2703 {
2704 uint loop_left = iter - loop_pos;
2705
2706 loop_left = MIN (loop_left, loop_step);
2707
2708 device_param->kernel_params_buf32[25] = loop_pos;
2709 device_param->kernel_params_buf32[26] = loop_left;
2710
2711 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2712
2713 if (data.devices_status == STATUS_CRACKED) break;
2714 if (data.devices_status == STATUS_ABORTED) break;
2715 if (data.devices_status == STATUS_QUIT) break;
2716 }
2717
2718 if (opts_type & OPTS_TYPE_HOOK23)
2719 {
2720 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2721
2722 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);
2723
2724 // do something with data
2725
2726 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);
2727 }
2728
2729 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2730 }
2731 }
2732
2733 static int run_rule_engine (const int rule_len, const char *rule_buf)
2734 {
2735 if (rule_len == 0)
2736 {
2737 return 0;
2738 }
2739 else if (rule_len == 1)
2740 {
2741 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2742 }
2743
2744 return 1;
2745 }
2746
2747 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2748 {
2749 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2750 {
2751 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);
2752 }
2753 else if (data.attack_kern == ATTACK_KERN_COMBI)
2754 {
2755 if (data.attack_mode == ATTACK_MODE_HYBRID2)
2756 {
2757 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2758 {
2759 for (u32 i = 0; i < pws_cnt; i++)
2760 {
2761 const u32 pw_len = device_param->pws_buf[i].pw_len;
2762
2763 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2764
2765 ptr[pw_len] = 0x01;
2766 }
2767 }
2768 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2769 {
2770 for (u32 i = 0; i < pws_cnt; i++)
2771 {
2772 const u32 pw_len = device_param->pws_buf[i].pw_len;
2773
2774 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2775
2776 ptr[pw_len] = 0x80;
2777 }
2778 }
2779 }
2780
2781 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);
2782 }
2783 else if (data.attack_kern == ATTACK_KERN_BF)
2784 {
2785 const u64 off = device_param->words_off;
2786
2787 device_param->kernel_params_mp_l_buf64[3] = off;
2788
2789 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2790 }
2791 }
2792
2793 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops, const int repeat)
2794 {
2795 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2796
2797 device_param->kernel_params_buf32[26] = kernel_loops;
2798 device_param->kernel_params_buf32[27] = kernel_loops;
2799
2800 // init some fake words
2801
2802 for (u32 i = 0; i < kernel_power; i++)
2803 {
2804 device_param->pws_buf[i].i[0] = i;
2805 device_param->pws_buf[i].i[1] = 0x01234567;
2806 device_param->pws_buf[i].pw_len = 4 + (i & 3);
2807 }
2808
2809 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);
2810
2811 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2812 {
2813 run_kernel_amp (device_param, kernel_power);
2814 }
2815
2816 // caching run
2817
2818 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2819 {
2820 run_kernel (KERN_RUN_1, device_param, kernel_power, false);
2821 }
2822 else
2823 {
2824 run_kernel (KERN_RUN_2, device_param, kernel_power, false);
2825 }
2826
2827 // now user repeats
2828
2829 for (int i = 0; i < repeat; i++)
2830 {
2831 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2832 {
2833 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2834 }
2835 else
2836 {
2837 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2838 }
2839 }
2840
2841 const double exec_ms_prev = get_avg_exec_time (device_param, repeat);
2842
2843 // reset fake words
2844
2845 memset (device_param->pws_buf, 0, kernel_power * sizeof (pw_t));
2846
2847 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);
2848 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);
2849
2850 return exec_ms_prev;
2851 }
2852
2853 static void autotune (hc_device_param_t *device_param)
2854 {
2855 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2856
2857 const u32 kernel_accel_min = device_param->kernel_accel_min;
2858 const u32 kernel_accel_max = device_param->kernel_accel_max;
2859
2860 const u32 kernel_loops_min = device_param->kernel_loops_min;
2861 const u32 kernel_loops_max = device_param->kernel_loops_max;
2862
2863 u32 kernel_accel = kernel_accel_min;
2864 u32 kernel_loops = kernel_loops_min;
2865
2866 // steps
2867
2868 #define STEPS_CNT 10
2869
2870 #define STEPS_ACCEL_CNT (STEPS_CNT + 2)
2871 #define STEPS_LOOPS_CNT (STEPS_CNT + 2)
2872
2873 u32 steps_accel[STEPS_ACCEL_CNT];
2874 u32 steps_loops[STEPS_LOOPS_CNT];
2875
2876 for (int i = 0; i < STEPS_ACCEL_CNT; i++)
2877 {
2878 steps_accel[i] = 1 << i;
2879 }
2880
2881 for (int i = 0; i < STEPS_LOOPS_CNT; i++)
2882 {
2883 steps_loops[i] = 1 << i;
2884 }
2885
2886 steps_accel[STEPS_CNT + 0] = kernel_accel_min;
2887 steps_accel[STEPS_CNT + 1] = kernel_accel_max;
2888
2889 steps_loops[STEPS_CNT + 0] = kernel_loops_min;
2890 steps_loops[STEPS_CNT + 1] = kernel_loops_max;
2891
2892 qsort (steps_accel, STEPS_ACCEL_CNT, sizeof (u32), sort_by_u32);
2893 qsort (steps_loops, STEPS_LOOPS_CNT, sizeof (u32), sort_by_u32);
2894
2895 // find out highest kernel-loops that stays below target_ms, we can use it later for multiplication as this is a linear function
2896
2897 u32 kernel_loops_tmp;
2898
2899 for (kernel_loops_tmp = kernel_loops_max; kernel_loops_tmp > kernel_loops_min; kernel_loops_tmp >>= 1)
2900 {
2901 const double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops_tmp, 1);
2902
2903 if (exec_ms < target_ms) break;
2904 }
2905
2906 // kernel-accel
2907
2908 if (kernel_accel_min < kernel_accel_max)
2909 {
2910 double e_best = 0;
2911
2912 for (int i = 0; i < STEPS_ACCEL_CNT; i++)
2913 {
2914 const u32 kernel_accel_try = steps_accel[i];
2915
2916 if (kernel_accel_try < kernel_accel_min) continue;
2917 if (kernel_accel_try > kernel_accel_max) break;
2918
2919 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_tmp, 1);
2920
2921 if (exec_ms > target_ms) break;
2922
2923 const double e = kernel_accel_try / exec_ms;
2924
2925 if (e > e_best)
2926 {
2927 kernel_accel = kernel_accel_try;
2928
2929 e_best = e;
2930 }
2931 }
2932 }
2933
2934 // kernel-loops final
2935
2936 if (kernel_loops_min < kernel_loops_max)
2937 {
2938 double e_best = 0;
2939
2940 for (int i = 0; i < STEPS_LOOPS_CNT; i++)
2941 {
2942 const u32 kernel_loops_try = steps_loops[i];
2943
2944 if (kernel_loops_try < kernel_loops_min) continue;
2945 if (kernel_loops_try > kernel_loops_max) break;
2946
2947 const double exec_ms = try_run (device_param, kernel_accel, kernel_loops_try, 1);
2948
2949 if (exec_ms > target_ms) break;
2950
2951 const double e = kernel_loops_try / exec_ms;
2952
2953 if (e > e_best)
2954 {
2955 kernel_loops = kernel_loops_try;
2956
2957 e_best = e;
2958 }
2959 }
2960 }
2961
2962 // final balance
2963
2964 u32 kernel_accel_best = kernel_accel;
2965 u32 kernel_loops_best = kernel_loops;
2966
2967 u32 exec_best = -1;
2968
2969 if ((kernel_accel_min < kernel_accel_max) || (kernel_loops_min < kernel_loops_max))
2970 {
2971 const double exec_ms = try_run (device_param, kernel_accel_best, kernel_loops_best, 1);
2972
2973 exec_best = exec_ms;
2974 }
2975
2976 // reset
2977
2978 if (kernel_accel_min < kernel_accel_max)
2979 {
2980 u32 kernel_accel_try = kernel_accel;
2981 u32 kernel_loops_try = kernel_loops;
2982
2983 for (int i = 0; i < 2; i++)
2984 {
2985 kernel_accel_try >>= 1;
2986 kernel_loops_try <<= 1;
2987
2988 if (kernel_accel_try < kernel_accel_min) break;
2989 if (kernel_loops_try > kernel_loops_max) break;
2990
2991 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
2992
2993 if (exec_ms < exec_best)
2994 {
2995 kernel_accel_best = kernel_accel_try;
2996 kernel_loops_best = kernel_loops_try;
2997
2998 exec_best = exec_ms;
2999 }
3000 }
3001 }
3002
3003 // reset
3004
3005 if (kernel_loops_min < kernel_loops_max)
3006 {
3007 u32 kernel_accel_try = kernel_accel;
3008 u32 kernel_loops_try = kernel_loops;
3009
3010 for (int i = 0; i < 2; i++)
3011 {
3012 kernel_accel_try <<= 1;
3013 kernel_loops_try >>= 1;
3014
3015 if (kernel_accel_try > kernel_accel_max) break;
3016 if (kernel_loops_try < kernel_loops_min) break;
3017
3018 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
3019
3020 if (exec_ms < exec_best)
3021 {
3022 kernel_accel_best = kernel_accel_try;
3023 kernel_loops_best = kernel_loops_try;
3024
3025 exec_best = exec_ms;
3026 }
3027 }
3028 }
3029
3030 // reset timer
3031
3032 device_param->exec_pos = 0;
3033
3034 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3035
3036 // store
3037
3038 kernel_accel = kernel_accel_best;
3039 kernel_loops = kernel_loops_best;
3040
3041 device_param->kernel_accel = kernel_accel;
3042 device_param->kernel_loops = kernel_loops;
3043
3044 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3045
3046 device_param->kernel_power = kernel_power;
3047
3048 #ifdef DEBUG
3049
3050 if (data.quiet == 0)
3051 {
3052 clear_prompt ();
3053
3054 log_info ("Device #%u: autotuned kernel-accel to %u\n"
3055 "Device #%u: autotuned kernel-loops to %u\n",
3056 device_param->device_id + 1,
3057 kernel_accel,
3058 device_param->device_id + 1,
3059 kernel_loops);
3060
3061 fprintf (stdout, "%s", PROMPT);
3062 fflush (stdout);
3063 }
3064
3065 #endif
3066 }
3067
3068 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3069 {
3070 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3071
3072 // init speed timer
3073
3074 uint speed_pos = device_param->speed_pos;
3075
3076 #ifdef _POSIX
3077 if (device_param->timer_speed.tv_sec == 0)
3078 {
3079 hc_timer_set (&device_param->timer_speed);
3080 }
3081 #endif
3082
3083 #ifdef _WIN
3084 if (device_param->timer_speed.QuadPart == 0)
3085 {
3086 hc_timer_set (&device_param->timer_speed);
3087 }
3088 #endif
3089
3090 // find higest password length, this is for optimization stuff
3091
3092 uint highest_pw_len = 0;
3093
3094 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3095 {
3096 }
3097 else if (data.attack_kern == ATTACK_KERN_COMBI)
3098 {
3099 }
3100 else if (data.attack_kern == ATTACK_KERN_BF)
3101 {
3102 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3103 + device_param->kernel_params_mp_l_buf32[5];
3104 }
3105
3106 // iteration type
3107
3108 uint innerloop_step = 0;
3109 uint innerloop_cnt = 0;
3110
3111 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3112 else innerloop_step = 1;
3113
3114 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3115 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3116 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3117
3118 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3119
3120 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3121 {
3122 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3123
3124 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3125
3126 if (data.devices_status == STATUS_CRACKED) break;
3127 if (data.devices_status == STATUS_ABORTED) break;
3128 if (data.devices_status == STATUS_QUIT) break;
3129 if (data.devices_status == STATUS_BYPASS) break;
3130
3131 salt_t *salt_buf = &data.salts_buf[salt_pos];
3132
3133 device_param->kernel_params_buf32[24] = salt_pos;
3134 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3135 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3136
3137 FILE *combs_fp = device_param->combs_fp;
3138
3139 if (data.attack_mode == ATTACK_MODE_COMBI)
3140 {
3141 rewind (combs_fp);
3142 }
3143
3144 // innerloops
3145
3146 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3147 {
3148 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3149
3150 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3151
3152 if (data.devices_status == STATUS_CRACKED) break;
3153 if (data.devices_status == STATUS_ABORTED) break;
3154 if (data.devices_status == STATUS_QUIT) break;
3155 if (data.devices_status == STATUS_BYPASS) break;
3156
3157 uint innerloop_left = innerloop_cnt - innerloop_pos;
3158
3159 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3160
3161 device_param->innerloop_pos = innerloop_pos;
3162 device_param->innerloop_left = innerloop_left;
3163
3164 device_param->kernel_params_buf32[27] = innerloop_left;
3165
3166 // i think we can get rid of this
3167 if (innerloop_left == 0)
3168 {
3169 puts ("bug, how should this happen????\n");
3170
3171 continue;
3172 }
3173
3174 if (data.salts_shown[salt_pos] == 1)
3175 {
3176 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3177
3178 continue;
3179 }
3180
3181 // initialize amplifiers
3182
3183 if (data.attack_mode == ATTACK_MODE_COMBI)
3184 {
3185 uint i = 0;
3186
3187 while (i < innerloop_left)
3188 {
3189 if (feof (combs_fp)) break;
3190
3191 int line_len = fgetl (combs_fp, line_buf);
3192
3193 if (line_len >= PW_MAX1) continue;
3194
3195 line_len = convert_from_hex (line_buf, line_len);
3196
3197 char *line_buf_new = line_buf;
3198
3199 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3200 {
3201 char rule_buf_out[BLOCK_SIZE] = { 0 };
3202
3203 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3204
3205 if (rule_len_out < 0)
3206 {
3207 data.words_progress_rejected[salt_pos] += pws_cnt;
3208
3209 continue;
3210 }
3211
3212 line_len = rule_len_out;
3213
3214 line_buf_new = rule_buf_out;
3215 }
3216
3217 line_len = MIN (line_len, PW_DICTMAX);
3218
3219 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3220
3221 memcpy (ptr, line_buf_new, line_len);
3222
3223 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3224
3225 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3226 {
3227 uppercase (ptr, line_len);
3228 }
3229
3230 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3231 {
3232 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3233 {
3234 ptr[line_len] = 0x80;
3235 }
3236
3237 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3238 {
3239 ptr[line_len] = 0x01;
3240 }
3241 }
3242
3243 device_param->combs_buf[i].pw_len = line_len;
3244
3245 i++;
3246 }
3247
3248 for (uint j = i; j < innerloop_left; j++)
3249 {
3250 device_param->combs_buf[j].i[0] = 0;
3251 device_param->combs_buf[j].i[1] = 0;
3252 device_param->combs_buf[j].i[2] = 0;
3253 device_param->combs_buf[j].i[3] = 0;
3254 device_param->combs_buf[j].i[4] = 0;
3255 device_param->combs_buf[j].i[5] = 0;
3256 device_param->combs_buf[j].i[6] = 0;
3257 device_param->combs_buf[j].i[7] = 0;
3258
3259 device_param->combs_buf[j].pw_len = 0;
3260 }
3261
3262 innerloop_left = i;
3263 }
3264 else if (data.attack_mode == ATTACK_MODE_BF)
3265 {
3266 u64 off = innerloop_pos;
3267
3268 device_param->kernel_params_mp_r_buf64[3] = off;
3269
3270 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3271 }
3272 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3273 {
3274 u64 off = innerloop_pos;
3275
3276 device_param->kernel_params_mp_buf64[3] = off;
3277
3278 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3279 }
3280 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3281 {
3282 u64 off = innerloop_pos;
3283
3284 device_param->kernel_params_mp_buf64[3] = off;
3285
3286 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3287 }
3288
3289 // copy amplifiers
3290
3291 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3292 {
3293 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);
3294 }
3295 else if (data.attack_mode == ATTACK_MODE_COMBI)
3296 {
3297 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);
3298 }
3299 else if (data.attack_mode == ATTACK_MODE_BF)
3300 {
3301 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);
3302 }
3303 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3304 {
3305 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);
3306 }
3307 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3308 {
3309 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);
3310 }
3311
3312 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3313
3314 if (data.benchmark == 1)
3315 {
3316 for (u32 i = 0; i < data.benchmark_repeats; i++)
3317 {
3318 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3319 }
3320 }
3321
3322 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3323
3324 if (data.devices_status == STATUS_CRACKED) break;
3325 if (data.devices_status == STATUS_ABORTED) break;
3326 if (data.devices_status == STATUS_QUIT) break;
3327
3328 /**
3329 * result
3330 */
3331
3332 hc_thread_mutex_lock (mux_display);
3333
3334 check_cracked (device_param, salt_pos);
3335
3336 hc_thread_mutex_unlock (mux_display);
3337
3338 /**
3339 * progress
3340 */
3341
3342 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3343
3344 if (data.benchmark == 1)
3345 {
3346 perf_sum_all = (perf_sum_all * data.benchmark_repeats) + perf_sum_all;
3347 }
3348
3349 hc_thread_mutex_lock (mux_counter);
3350
3351 data.words_progress_done[salt_pos] += perf_sum_all;
3352
3353 hc_thread_mutex_unlock (mux_counter);
3354
3355 /**
3356 * speed
3357 */
3358
3359 float speed_ms;
3360
3361 hc_timer_get (device_param->timer_speed, speed_ms);
3362
3363 hc_timer_set (&device_param->timer_speed);
3364
3365 hc_thread_mutex_lock (mux_display);
3366
3367 device_param->speed_cnt[speed_pos] = perf_sum_all;
3368
3369 device_param->speed_ms[speed_pos] = speed_ms;
3370
3371 device_param->speed_rec[speed_pos] = device_param->timer_speed;
3372
3373 hc_thread_mutex_unlock (mux_display);
3374
3375 speed_pos++;
3376
3377 if (speed_pos == SPEED_CACHE)
3378 {
3379 speed_pos = 0;
3380 }
3381
3382 /**
3383 * benchmark
3384 */
3385
3386 if (data.benchmark == 1) break;
3387 }
3388 }
3389
3390 device_param->speed_pos = speed_pos;
3391
3392 myfree (line_buf);
3393 }
3394
3395 static void load_segment (wl_data_t *wl_data, FILE *fd)
3396 {
3397 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3398
3399 wl_data->pos = 0;
3400
3401 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3402
3403 wl_data->buf[wl_data->cnt] = 0;
3404
3405 if (wl_data->cnt == 0) return;
3406
3407 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3408
3409 while (!feof (fd))
3410 {
3411 if (wl_data->cnt == wl_data->avail)
3412 {
3413 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3414
3415 wl_data->avail += wl_data->incr;
3416 }
3417
3418 const int c = fgetc (fd);
3419
3420 if (c == EOF) break;
3421
3422 wl_data->buf[wl_data->cnt] = (char) c;
3423
3424 wl_data->cnt++;
3425
3426 if (c == '\n') break;
3427 }
3428
3429 // ensure stream ends with a newline
3430
3431 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3432 {
3433 wl_data->cnt++;
3434
3435 wl_data->buf[wl_data->cnt - 1] = '\n';
3436 }
3437
3438 return;
3439 }
3440
3441 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3442 {
3443 char *ptr = buf;
3444
3445 for (u32 i = 0; i < sz; i++, ptr++)
3446 {
3447 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3448
3449 if (i == 7)
3450 {
3451 *off = i;
3452 *len = i;
3453
3454 return;
3455 }
3456
3457 if (*ptr != '\n') continue;
3458
3459 *off = i + 1;
3460
3461 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3462
3463 *len = i;
3464
3465 return;
3466 }
3467
3468 *off = sz;
3469 *len = sz;
3470 }
3471
3472 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3473 {
3474 char *ptr = buf;
3475
3476 for (u32 i = 0; i < sz; i++, ptr++)
3477 {
3478 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3479
3480 if (*ptr != '\n') continue;
3481
3482 *off = i + 1;
3483
3484 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3485
3486 *len = i;
3487
3488 return;
3489 }
3490
3491 *off = sz;
3492 *len = sz;
3493 }
3494
3495 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3496 {
3497 char *ptr = buf;
3498
3499 for (u32 i = 0; i < sz; i++, ptr++)
3500 {
3501 if (*ptr != '\n') continue;
3502
3503 *off = i + 1;
3504
3505 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3506
3507 *len = i;
3508
3509 return;
3510 }
3511
3512 *off = sz;
3513 *len = sz;
3514 }
3515
3516 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3517 {
3518 while (wl_data->pos < wl_data->cnt)
3519 {
3520 uint off;
3521 uint len;
3522
3523 char *ptr = wl_data->buf + wl_data->pos;
3524
3525 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3526
3527 wl_data->pos += off;
3528
3529 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3530 {
3531 char rule_buf_out[BLOCK_SIZE] = { 0 };
3532
3533 int rule_len_out = -1;
3534
3535 if (len < BLOCK_SIZE)
3536 {
3537 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3538 }
3539
3540 if (rule_len_out < 0)
3541 {
3542 continue;
3543 }
3544
3545 if (rule_len_out > PW_MAX)
3546 {
3547 continue;
3548 }
3549 }
3550 else
3551 {
3552 if (len > PW_MAX)
3553 {
3554 continue;
3555 }
3556 }
3557
3558 *out_buf = ptr;
3559 *out_len = len;
3560
3561 return;
3562 }
3563
3564 if (feof (fd))
3565 {
3566 fprintf (stderr, "BUG feof()!!\n");
3567
3568 return;
3569 }
3570
3571 load_segment (wl_data, fd);
3572
3573 get_next_word (wl_data, fd, out_buf, out_len);
3574 }
3575
3576 #ifdef _POSIX
3577 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3578 #endif
3579
3580 #ifdef _WIN
3581 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3582 #endif
3583 {
3584 hc_signal (NULL);
3585
3586 dictstat_t d;
3587
3588 d.cnt = 0;
3589
3590 #ifdef _POSIX
3591 fstat (fileno (fd), &d.stat);
3592 #endif
3593
3594 #ifdef _WIN
3595 _fstat64 (fileno (fd), &d.stat);
3596 #endif
3597
3598 d.stat.st_mode = 0;
3599 d.stat.st_nlink = 0;
3600 d.stat.st_uid = 0;
3601 d.stat.st_gid = 0;
3602 d.stat.st_rdev = 0;
3603 d.stat.st_atime = 0;
3604
3605 #ifdef _POSIX
3606 d.stat.st_blksize = 0;
3607 d.stat.st_blocks = 0;
3608 #endif
3609
3610 if (d.stat.st_size == 0) return 0;
3611
3612 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3613
3614 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3615 {
3616 if (d_cache)
3617 {
3618 u64 cnt = d_cache->cnt;
3619
3620 u64 keyspace = cnt;
3621
3622 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3623 {
3624 keyspace *= data.kernel_rules_cnt;
3625 }
3626 else if (data.attack_kern == ATTACK_KERN_COMBI)
3627 {
3628 keyspace *= data.combs_cnt;
3629 }
3630
3631 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);
3632 if (data.quiet == 0) log_info ("");
3633
3634 hc_signal (sigHandler_default);
3635
3636 return (keyspace);
3637 }
3638 }
3639
3640 time_t now = 0;
3641 time_t prev = 0;
3642
3643 u64 comp = 0;
3644 u64 cnt = 0;
3645 u64 cnt2 = 0;
3646
3647 while (!feof (fd))
3648 {
3649 load_segment (wl_data, fd);
3650
3651 comp += wl_data->cnt;
3652
3653 u32 i = 0;
3654
3655 while (i < wl_data->cnt)
3656 {
3657 u32 len;
3658 u32 off;
3659
3660 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3661
3662 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3663 {
3664 char rule_buf_out[BLOCK_SIZE] = { 0 };
3665
3666 int rule_len_out = -1;
3667
3668 if (len < BLOCK_SIZE)
3669 {
3670 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3671 }
3672
3673 if (rule_len_out < 0)
3674 {
3675 len = PW_MAX1;
3676 }
3677 else
3678 {
3679 len = rule_len_out;
3680 }
3681 }
3682
3683 if (len < PW_MAX1)
3684 {
3685 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3686 {
3687 cnt += data.kernel_rules_cnt;
3688 }
3689 else if (data.attack_kern == ATTACK_KERN_COMBI)
3690 {
3691 cnt += data.combs_cnt;
3692 }
3693
3694 d.cnt++;
3695 }
3696
3697 i += off;
3698
3699 cnt2++;
3700 }
3701
3702 time (&now);
3703
3704 if ((now - prev) == 0) continue;
3705
3706 float percent = (float) comp / (float) d.stat.st_size;
3707
3708 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);
3709
3710 time (&prev);
3711 }
3712
3713 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);
3714 if (data.quiet == 0) log_info ("");
3715
3716 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3717
3718 hc_signal (sigHandler_default);
3719
3720 return (cnt);
3721 }
3722
3723 static void *thread_monitor (void *p)
3724 {
3725 uint runtime_check = 0;
3726 uint remove_check = 0;
3727 uint status_check = 0;
3728 uint restore_check = 0;
3729
3730 uint restore_left = data.restore_timer;
3731 uint remove_left = data.remove_timer;
3732 uint status_left = data.status_timer;
3733
3734 #ifdef HAVE_HWMON
3735 uint hwmon_check = 0;
3736
3737 // these variables are mainly used for fan control (AMD only)
3738
3739 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3740
3741 // temperature controller "loopback" values
3742
3743 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3744 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3745
3746 #ifdef HAVE_ADL
3747 int temp_threshold = 1; // degrees celcius
3748
3749 int fan_speed_min = 15; // in percentage
3750 int fan_speed_max = 100;
3751 #endif // HAVE_ADL
3752
3753 time_t last_temp_check_time;
3754 #endif // HAVE_HWMON
3755
3756 uint sleep_time = 1;
3757
3758 if (data.runtime)
3759 {
3760 runtime_check = 1;
3761 }
3762
3763 if (data.restore_timer)
3764 {
3765 restore_check = 1;
3766 }
3767
3768 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3769 {
3770 remove_check = 1;
3771 }
3772
3773 if (data.status == 1)
3774 {
3775 status_check = 1;
3776 }
3777
3778 #ifdef HAVE_HWMON
3779 if (data.gpu_temp_disable == 0)
3780 {
3781 time (&last_temp_check_time);
3782
3783 hwmon_check = 1;
3784 }
3785 #endif
3786
3787 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3788 {
3789 #ifdef HAVE_HWMON
3790 if (hwmon_check == 0)
3791 #endif
3792 return (p);
3793 }
3794
3795 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3796 {
3797 hc_sleep (sleep_time);
3798
3799 if (data.devices_status != STATUS_RUNNING) continue;
3800
3801 #ifdef HAVE_HWMON
3802 if (hwmon_check == 1)
3803 {
3804 hc_thread_mutex_lock (mux_adl);
3805
3806 time_t temp_check_time;
3807
3808 time (&temp_check_time);
3809
3810 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3811
3812 if (Ta == 0) Ta = 1;
3813
3814 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3815 {
3816 hc_device_param_t *device_param = &data.devices_param[device_id];
3817
3818 if (device_param->skipped) continue;
3819
3820 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3821
3822 const int temperature = hm_get_temperature_with_device_id (device_id);
3823
3824 if (temperature > (int) data.gpu_temp_abort)
3825 {
3826 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3827
3828 if (data.devices_status != STATUS_QUIT) myabort ();
3829
3830 break;
3831 }
3832
3833 #ifdef HAVE_ADL
3834 const int gpu_temp_retain = data.gpu_temp_retain;
3835
3836 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3837 {
3838 if (data.hm_device[device_id].fan_supported == 1)
3839 {
3840 int temp_cur = temperature;
3841
3842 int temp_diff_new = gpu_temp_retain - temp_cur;
3843
3844 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3845
3846 // calculate Ta value (time difference in seconds between the last check and this check)
3847
3848 last_temp_check_time = temp_check_time;
3849
3850 float Kp = 1.8;
3851 float Ki = 0.005;
3852 float Kd = 6;
3853
3854 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3855
3856 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);
3857
3858 if (abs (fan_diff_required) >= temp_threshold)
3859 {
3860 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3861
3862 int fan_speed_level = fan_speed_cur;
3863
3864 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3865
3866 int fan_speed_new = fan_speed_level - fan_diff_required;
3867
3868 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3869 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3870
3871 if (fan_speed_new != fan_speed_cur)
3872 {
3873 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3874 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3875
3876 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3877 {
3878 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3879
3880 fan_speed_chgd[device_id] = 1;
3881 }
3882
3883 temp_diff_old[device_id] = temp_diff_new;
3884 }
3885 }
3886 }
3887 }
3888 #endif // HAVE_ADL
3889 }
3890
3891 hc_thread_mutex_unlock (mux_adl);
3892 }
3893 #endif // HAVE_HWMON
3894
3895 if (restore_check == 1)
3896 {
3897 restore_left--;
3898
3899 if (restore_left == 0)
3900 {
3901 if (data.restore_disable == 0) cycle_restore ();
3902
3903 restore_left = data.restore_timer;
3904 }
3905 }
3906
3907 if ((runtime_check == 1) && (data.runtime_start > 0))
3908 {
3909 time_t runtime_cur;
3910
3911 time (&runtime_cur);
3912
3913 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3914
3915 if (runtime_left <= 0)
3916 {
3917 if (data.benchmark == 0)
3918 {
3919 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3920 }
3921
3922 if (data.devices_status != STATUS_QUIT) myabort ();
3923 }
3924 }
3925
3926 if (remove_check == 1)
3927 {
3928 remove_left--;
3929
3930 if (remove_left == 0)
3931 {
3932 if (data.digests_saved != data.digests_done)
3933 {
3934 data.digests_saved = data.digests_done;
3935
3936 save_hash ();
3937 }
3938
3939 remove_left = data.remove_timer;
3940 }
3941 }
3942
3943 if (status_check == 1)
3944 {
3945 status_left--;
3946
3947 if (status_left == 0)
3948 {
3949 hc_thread_mutex_lock (mux_display);
3950
3951 if (data.quiet == 0) clear_prompt ();
3952
3953 if (data.quiet == 0) log_info ("");
3954
3955 status_display ();
3956
3957 if (data.quiet == 0) log_info ("");
3958
3959 hc_thread_mutex_unlock (mux_display);
3960
3961 status_left = data.status_timer;
3962 }
3963 }
3964 }
3965
3966 #ifdef HAVE_HWMON
3967 myfree (fan_speed_chgd);
3968
3969 myfree (temp_diff_old);
3970 myfree (temp_diff_sum);
3971 #endif
3972
3973 p = NULL;
3974
3975 return (p);
3976 }
3977
3978 static void *thread_outfile_remove (void *p)
3979 {
3980 // some hash-dependent constants
3981 char *outfile_dir = data.outfile_check_directory;
3982 uint dgst_size = data.dgst_size;
3983 uint isSalted = data.isSalted;
3984 uint esalt_size = data.esalt_size;
3985 uint hash_mode = data.hash_mode;
3986
3987 uint outfile_check_timer = data.outfile_check_timer;
3988
3989 char separator = data.separator;
3990
3991 // some hash-dependent functions
3992 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3993 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3994
3995 // buffers
3996 hash_t hash_buf = { 0, 0, 0, 0, 0 };
3997
3998 hash_buf.digest = mymalloc (dgst_size);
3999
4000 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4001
4002 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4003
4004 uint digest_buf[64] = { 0 };
4005
4006 outfile_data_t *out_info = NULL;
4007
4008 char **out_files = NULL;
4009
4010 time_t folder_mtime = 0;
4011
4012 int out_cnt = 0;
4013
4014 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4015
4016 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4017 {
4018 hc_sleep (1);
4019
4020 if (data.devices_status != STATUS_RUNNING) continue;
4021
4022 check_left--;
4023
4024 if (check_left == 0)
4025 {
4026 struct stat outfile_check_stat;
4027
4028 if (stat (outfile_dir, &outfile_check_stat) == 0)
4029 {
4030 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4031
4032 if (is_dir == 1)
4033 {
4034 if (outfile_check_stat.st_mtime > folder_mtime)
4035 {
4036 char **out_files_new = scan_directory (outfile_dir);
4037
4038 int out_cnt_new = count_dictionaries (out_files_new);
4039
4040 outfile_data_t *out_info_new = NULL;
4041
4042 if (out_cnt_new > 0)
4043 {
4044 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4045
4046 for (int i = 0; i < out_cnt_new; i++)
4047 {
4048 out_info_new[i].file_name = out_files_new[i];
4049
4050 // check if there are files that we have seen/checked before (and not changed)
4051
4052 for (int j = 0; j < out_cnt; j++)
4053 {
4054 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4055 {
4056 struct stat outfile_stat;
4057
4058 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4059 {
4060 if (outfile_stat.st_ctime == out_info[j].ctime)
4061 {
4062 out_info_new[i].ctime = out_info[j].ctime;
4063 out_info_new[i].seek = out_info[j].seek;
4064 }
4065 }
4066 }
4067 }
4068 }
4069 }
4070
4071 local_free (out_info);
4072 local_free (out_files);
4073
4074 out_files = out_files_new;
4075 out_cnt = out_cnt_new;
4076 out_info = out_info_new;
4077
4078 folder_mtime = outfile_check_stat.st_mtime;
4079 }
4080
4081 for (int j = 0; j < out_cnt; j++)
4082 {
4083 FILE *fp = fopen (out_info[j].file_name, "rb");
4084
4085 if (fp != NULL)
4086 {
4087 //hc_thread_mutex_lock (mux_display);
4088
4089 #ifdef _POSIX
4090 struct stat outfile_stat;
4091
4092 fstat (fileno (fp), &outfile_stat);
4093 #endif
4094
4095 #ifdef _WIN
4096 struct stat64 outfile_stat;
4097
4098 _fstat64 (fileno (fp), &outfile_stat);
4099 #endif
4100
4101 if (outfile_stat.st_ctime > out_info[j].ctime)
4102 {
4103 out_info[j].ctime = outfile_stat.st_ctime;
4104 out_info[j].seek = 0;
4105 }
4106
4107 fseek (fp, out_info[j].seek, SEEK_SET);
4108
4109 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4110
4111 while (!feof (fp))
4112 {
4113 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4114
4115 if (ptr == NULL) break;
4116
4117 int line_len = strlen (line_buf);
4118
4119 if (line_len <= 0) continue;
4120
4121 int iter = MAX_CUT_TRIES;
4122
4123 for (uint i = line_len - 1; i && iter; i--, line_len--)
4124 {
4125 if (line_buf[i] != separator) continue;
4126
4127 int parser_status = PARSER_OK;
4128
4129 if ((hash_mode != 2500) && (hash_mode != 6800))
4130 {
4131 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4132 }
4133
4134 uint found = 0;
4135
4136 if (parser_status == PARSER_OK)
4137 {
4138 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4139 {
4140 if (data.salts_shown[salt_pos] == 1) continue;
4141
4142 salt_t *salt_buf = &data.salts_buf[salt_pos];
4143
4144 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4145 {
4146 uint idx = salt_buf->digests_offset + digest_pos;
4147
4148 if (data.digests_shown[idx] == 1) continue;
4149
4150 uint cracked = 0;
4151
4152 if (hash_mode == 6800)
4153 {
4154 if (i == salt_buf->salt_len)
4155 {
4156 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4157 }
4158 }
4159 else if (hash_mode == 2500)
4160 {
4161 // BSSID : MAC1 : MAC2 (:plain)
4162 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4163 {
4164 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4165
4166 if (!cracked) continue;
4167
4168 // now compare MAC1 and MAC2 too, since we have this additional info
4169 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4170 char *mac2_pos = mac1_pos + 12 + 1;
4171
4172 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4173 wpa_t *wpa = &wpas[salt_pos];
4174
4175 uint pke[25] = { 0 };
4176
4177 char *pke_ptr = (char *) pke;
4178
4179 for (uint i = 0; i < 25; i++)
4180 {
4181 pke[i] = byte_swap_32 (wpa->pke[i]);
4182 }
4183
4184 u8 mac1[6] = { 0 };
4185 u8 mac2[6] = { 0 };
4186
4187 memcpy (mac1, pke_ptr + 23, 6);
4188 memcpy (mac2, pke_ptr + 29, 6);
4189
4190 // compare hex string(s) vs binary MAC address(es)
4191
4192 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4193 {
4194 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4195 {
4196 cracked = 0;
4197 break;
4198 }
4199 }
4200
4201 // early skip ;)
4202 if (!cracked) continue;
4203
4204 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4205 {
4206 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4207 {
4208 cracked = 0;
4209 break;
4210 }
4211 }
4212 }
4213 }
4214 else
4215 {
4216 char *digests_buf_ptr = (char *) data.digests_buf;
4217
4218 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4219
4220 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4221 }
4222
4223 if (cracked == 1)
4224 {
4225 found = 1;
4226
4227 data.digests_shown[idx] = 1;
4228
4229 data.digests_done++;
4230
4231 salt_buf->digests_done++;
4232
4233 if (salt_buf->digests_done == salt_buf->digests_cnt)
4234 {
4235 data.salts_shown[salt_pos] = 1;
4236
4237 data.salts_done++;
4238
4239 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4240 }
4241 }
4242 }
4243
4244 if (data.devices_status == STATUS_CRACKED) break;
4245 }
4246 }
4247
4248 if (found) break;
4249
4250 if (data.devices_status == STATUS_CRACKED) break;
4251
4252 iter--;
4253 }
4254
4255 if (data.devices_status == STATUS_CRACKED) break;
4256 }
4257
4258 myfree (line_buf);
4259
4260 out_info[j].seek = ftell (fp);
4261
4262 //hc_thread_mutex_unlock (mux_display);
4263
4264 fclose (fp);
4265 }
4266 }
4267 }
4268 }
4269
4270 check_left = outfile_check_timer;
4271 }
4272 }
4273
4274 if (esalt_size) local_free (hash_buf.esalt);
4275
4276 if (isSalted) local_free (hash_buf.salt);
4277
4278 local_free (hash_buf.digest);
4279
4280 local_free (out_info);
4281
4282 local_free (out_files);
4283
4284 p = NULL;
4285
4286 return (p);
4287 }
4288
4289 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4290 {
4291 if (device_param->pws_cnt < device_param->kernel_power)
4292 {
4293 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4294
4295 u8 *ptr = (u8 *) pw->i;
4296
4297 memcpy (ptr, pw_buf, pw_len);
4298
4299 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4300
4301 pw->pw_len = pw_len;
4302
4303 device_param->pws_cnt++;
4304 }
4305 else
4306 {
4307 fprintf (stderr, "BUG pw_add()!!\n");
4308
4309 return;
4310 }
4311 }
4312
4313 static uint get_work (hc_device_param_t *device_param, const u64 max, const bool allow_div)
4314 {
4315 hc_thread_mutex_lock (mux_dispatcher);
4316
4317 const u64 words_cur = data.words_cur;
4318 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4319
4320 device_param->words_off = words_cur;
4321
4322 const u64 words_left = words_base - words_cur;
4323
4324 if (allow_div)
4325 {
4326 if (data.kernel_power_all > words_left)
4327 {
4328 if (data.kernel_power_div == 0)
4329 {
4330 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4331 }
4332 }
4333
4334 if (data.kernel_power_div)
4335 {
4336 if (device_param->kernel_power == device_param->kernel_power_user)
4337 {
4338 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4339
4340 if (kernel_power_new < device_param->kernel_power)
4341 {
4342 device_param->kernel_power = kernel_power_new;
4343 }
4344 }
4345 }
4346 }
4347
4348 const uint kernel_power = device_param->kernel_power;
4349
4350 uint work = MIN (words_left, kernel_power);
4351
4352 work = MIN (work, max);
4353
4354 data.words_cur += work;
4355
4356 hc_thread_mutex_unlock (mux_dispatcher);
4357
4358 return work;
4359 }
4360
4361 static void *thread_calc_stdin (void *p)
4362 {
4363 hc_device_param_t *device_param = (hc_device_param_t *) p;
4364
4365 if (device_param->skipped) return NULL;
4366
4367 autotune (device_param);
4368
4369 char *buf = (char *) mymalloc (HCBUFSIZ);
4370
4371 const uint attack_kern = data.attack_kern;
4372
4373 const uint kernel_power = device_param->kernel_power;
4374
4375 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4376 {
4377 hc_thread_mutex_lock (mux_dispatcher);
4378
4379 if (feof (stdin) != 0)
4380 {
4381 hc_thread_mutex_unlock (mux_dispatcher);
4382
4383 break;
4384 }
4385
4386 uint words_cur = 0;
4387
4388 while (words_cur < kernel_power)
4389 {
4390 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4391
4392 if (line_buf == NULL) break;
4393
4394 uint line_len = in_superchop (line_buf);
4395
4396 line_len = convert_from_hex (line_buf, line_len);
4397
4398 // post-process rule engine
4399
4400 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4401 {
4402 char rule_buf_out[BLOCK_SIZE] = { 0 };
4403
4404 int rule_len_out = -1;
4405
4406 if (line_len < BLOCK_SIZE)
4407 {
4408 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4409 }
4410
4411 if (rule_len_out < 0) continue;
4412
4413 line_buf = rule_buf_out;
4414 line_len = rule_len_out;
4415 }
4416
4417 if (line_len > PW_MAX)
4418 {
4419 continue;
4420 }
4421
4422 if (attack_kern == ATTACK_KERN_STRAIGHT)
4423 {
4424 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4425 {
4426 hc_thread_mutex_lock (mux_counter);
4427
4428 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4429 {
4430 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4431 }
4432
4433 hc_thread_mutex_unlock (mux_counter);
4434
4435 continue;
4436 }
4437 }
4438 else if (attack_kern == ATTACK_KERN_COMBI)
4439 {
4440 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4441 // since we still need to combine the plains
4442
4443 if (line_len > data.pw_max)
4444 {
4445 hc_thread_mutex_lock (mux_counter);
4446
4447 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4448 {
4449 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4450 }
4451
4452 hc_thread_mutex_unlock (mux_counter);
4453
4454 continue;
4455 }
4456 }
4457
4458 pw_add (device_param, (u8 *) line_buf, line_len);
4459
4460 words_cur++;
4461
4462 if (data.devices_status == STATUS_CRACKED) break;
4463 if (data.devices_status == STATUS_ABORTED) break;
4464 if (data.devices_status == STATUS_QUIT) break;
4465 if (data.devices_status == STATUS_BYPASS) break;
4466 }
4467
4468 hc_thread_mutex_unlock (mux_dispatcher);
4469
4470 if (data.devices_status == STATUS_CRACKED) break;
4471 if (data.devices_status == STATUS_ABORTED) break;
4472 if (data.devices_status == STATUS_QUIT) break;
4473 if (data.devices_status == STATUS_BYPASS) break;
4474
4475 // flush
4476
4477 const uint pws_cnt = device_param->pws_cnt;
4478
4479 if (pws_cnt)
4480 {
4481 run_copy (device_param, pws_cnt);
4482
4483 run_cracker (device_param, pws_cnt);
4484
4485 device_param->pws_cnt = 0;
4486
4487 if (attack_kern == ATTACK_KERN_STRAIGHT)
4488 {
4489 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4490 }
4491 else if (attack_kern == ATTACK_KERN_COMBI)
4492 {
4493 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4494 }
4495 }
4496 }
4497
4498 device_param->kernel_accel = 0;
4499 device_param->kernel_loops = 0;
4500
4501 myfree (buf);
4502
4503 return NULL;
4504 }
4505
4506 static void *thread_calc (void *p)
4507 {
4508 hc_device_param_t *device_param = (hc_device_param_t *) p;
4509
4510 if (device_param->skipped) return NULL;
4511
4512 autotune (device_param);
4513
4514 const uint attack_mode = data.attack_mode;
4515 const uint attack_kern = data.attack_kern;
4516
4517 if (attack_mode == ATTACK_MODE_BF)
4518 {
4519 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4520 {
4521 const uint work = get_work (device_param, -1, true);
4522
4523 if (work == 0) break;
4524
4525 const u64 words_off = device_param->words_off;
4526 const u64 words_fin = words_off + work;
4527
4528 const uint pws_cnt = work;
4529
4530 device_param->pws_cnt = pws_cnt;
4531
4532 if (pws_cnt)
4533 {
4534 run_copy (device_param, pws_cnt);
4535
4536 run_cracker (device_param, pws_cnt);
4537
4538 device_param->pws_cnt = 0;
4539
4540 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4541 }
4542
4543 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4544
4545 if (data.devices_status == STATUS_CRACKED) break;
4546 if (data.devices_status == STATUS_ABORTED) break;
4547 if (data.devices_status == STATUS_QUIT) break;
4548 if (data.devices_status == STATUS_BYPASS) break;
4549
4550 if (data.benchmark == 1) break;
4551
4552 device_param->words_done = words_fin;
4553 }
4554 }
4555 else
4556 {
4557 const uint segment_size = data.segment_size;
4558
4559 char *dictfile = data.dictfile;
4560
4561 if (attack_mode == ATTACK_MODE_COMBI)
4562 {
4563 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4564 {
4565 dictfile = data.dictfile2;
4566 }
4567 }
4568
4569 FILE *fd = fopen (dictfile, "rb");
4570
4571 if (fd == NULL)
4572 {
4573 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4574
4575 return NULL;
4576 }
4577
4578 if (attack_mode == ATTACK_MODE_COMBI)
4579 {
4580 const uint combs_mode = data.combs_mode;
4581
4582 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4583 {
4584 const char *dictfilec = data.dictfile2;
4585
4586 FILE *combs_fp = fopen (dictfilec, "rb");
4587
4588 if (combs_fp == NULL)
4589 {
4590 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4591
4592 fclose (fd);
4593
4594 return NULL;
4595 }
4596
4597 device_param->combs_fp = combs_fp;
4598 }
4599 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4600 {
4601 const char *dictfilec = data.dictfile;
4602
4603 FILE *combs_fp = fopen (dictfilec, "rb");
4604
4605 if (combs_fp == NULL)
4606 {
4607 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4608
4609 fclose (fd);
4610
4611 return NULL;
4612 }
4613
4614 device_param->combs_fp = combs_fp;
4615 }
4616 }
4617
4618 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4619
4620 wl_data->buf = (char *) mymalloc (segment_size);
4621 wl_data->avail = segment_size;
4622 wl_data->incr = segment_size;
4623 wl_data->cnt = 0;
4624 wl_data->pos = 0;
4625
4626 u64 words_cur = 0;
4627
4628 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4629 {
4630 u64 words_off = 0;
4631 u64 words_fin = 0;
4632
4633 bool allow_div = true;
4634
4635 u64 max = -1;
4636
4637 while (max)
4638 {
4639 const uint work = get_work (device_param, max, allow_div);
4640
4641 allow_div = false;
4642
4643 if (work == 0) break;
4644
4645 words_off = device_param->words_off;
4646 words_fin = words_off + work;
4647
4648 char *line_buf;
4649 uint line_len;
4650
4651 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4652
4653 max = 0;
4654
4655 for ( ; words_cur < words_fin; words_cur++)
4656 {
4657 get_next_word (wl_data, fd, &line_buf, &line_len);
4658
4659 line_len = convert_from_hex (line_buf, line_len);
4660
4661 // post-process rule engine
4662
4663 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4664 {
4665 char rule_buf_out[BLOCK_SIZE] = { 0 };
4666
4667 int rule_len_out = -1;
4668
4669 if (line_len < BLOCK_SIZE)
4670 {
4671 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4672 }
4673
4674 if (rule_len_out < 0) continue;
4675
4676 line_buf = rule_buf_out;
4677 line_len = rule_len_out;
4678 }
4679
4680 if (attack_kern == ATTACK_KERN_STRAIGHT)
4681 {
4682 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4683 {
4684 max++;
4685
4686 hc_thread_mutex_lock (mux_counter);
4687
4688 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4689 {
4690 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4691 }
4692
4693 hc_thread_mutex_unlock (mux_counter);
4694
4695 continue;
4696 }
4697 }
4698 else if (attack_kern == ATTACK_KERN_COMBI)
4699 {
4700 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4701 // since we still need to combine the plains
4702
4703 if (line_len > data.pw_max)
4704 {
4705 max++;
4706
4707 hc_thread_mutex_lock (mux_counter);
4708
4709 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4710 {
4711 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4712 }
4713
4714 hc_thread_mutex_unlock (mux_counter);
4715
4716 continue;
4717 }
4718 }
4719
4720 pw_add (device_param, (u8 *) line_buf, line_len);
4721
4722 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4723
4724 if (data.devices_status == STATUS_CRACKED) break;
4725 if (data.devices_status == STATUS_ABORTED) break;
4726 if (data.devices_status == STATUS_QUIT) break;
4727 if (data.devices_status == STATUS_BYPASS) break;
4728 }
4729
4730 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4731
4732 if (data.devices_status == STATUS_CRACKED) break;
4733 if (data.devices_status == STATUS_ABORTED) break;
4734 if (data.devices_status == STATUS_QUIT) break;
4735 if (data.devices_status == STATUS_BYPASS) break;
4736 }
4737
4738 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4739
4740 if (data.devices_status == STATUS_CRACKED) break;
4741 if (data.devices_status == STATUS_ABORTED) break;
4742 if (data.devices_status == STATUS_QUIT) break;
4743 if (data.devices_status == STATUS_BYPASS) break;
4744
4745 //
4746 // flush
4747 //
4748
4749 const uint pws_cnt = device_param->pws_cnt;
4750
4751 if (pws_cnt)
4752 {
4753 run_copy (device_param, pws_cnt);
4754
4755 run_cracker (device_param, pws_cnt);
4756
4757 device_param->pws_cnt = 0;
4758
4759 if (attack_kern == ATTACK_KERN_STRAIGHT)
4760 {
4761 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4762 }
4763 else if (attack_kern == ATTACK_KERN_COMBI)
4764 {
4765 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4766 }
4767 }
4768
4769 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4770
4771 if (data.devices_status == STATUS_CRACKED) break;
4772 if (data.devices_status == STATUS_ABORTED) break;
4773 if (data.devices_status == STATUS_QUIT) break;
4774 if (data.devices_status == STATUS_BYPASS) break;
4775
4776 if (words_fin == 0) break;
4777
4778 device_param->words_done = words_fin;
4779 }
4780
4781 if (attack_mode == ATTACK_MODE_COMBI)
4782 {
4783 fclose (device_param->combs_fp);
4784 }
4785
4786 free (wl_data->buf);
4787 free (wl_data);
4788
4789 fclose (fd);
4790 }
4791
4792 device_param->kernel_accel = 0;
4793 device_param->kernel_loops = 0;
4794
4795 return NULL;
4796 }
4797
4798 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4799 {
4800 if (!device_param)
4801 {
4802 log_error ("ERROR: %s : Invalid argument", __func__);
4803
4804 exit (-1);
4805 }
4806
4807 salt_t *salt_buf = &data.salts_buf[salt_pos];
4808
4809 device_param->kernel_params_buf32[24] = salt_pos;
4810 device_param->kernel_params_buf32[27] = 1;
4811 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4812 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4813 device_param->kernel_params_buf32[30] = 0;
4814 device_param->kernel_params_buf32[31] = 1;
4815
4816 char *dictfile_old = data.dictfile;
4817
4818 const char *weak_hash_check = "weak-hash-check";
4819
4820 data.dictfile = (char *) weak_hash_check;
4821
4822 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4823
4824 data.kernel_rules_buf[0].cmds[0] = 0;
4825
4826 /**
4827 * run the kernel
4828 */
4829
4830 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4831 {
4832 run_kernel (KERN_RUN_1, device_param, 1, false);
4833 }
4834 else
4835 {
4836 run_kernel (KERN_RUN_1, device_param, 1, false);
4837
4838 uint loop_step = 16;
4839
4840 const uint iter = salt_buf->salt_iter;
4841
4842 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4843 {
4844 uint loop_left = iter - loop_pos;
4845
4846 loop_left = MIN (loop_left, loop_step);
4847
4848 device_param->kernel_params_buf32[25] = loop_pos;
4849 device_param->kernel_params_buf32[26] = loop_left;
4850
4851 run_kernel (KERN_RUN_2, device_param, 1, false);
4852 }
4853
4854 run_kernel (KERN_RUN_3, device_param, 1, false);
4855 }
4856
4857 /**
4858 * result
4859 */
4860
4861 check_cracked (device_param, salt_pos);
4862
4863 /**
4864 * cleanup
4865 */
4866
4867 device_param->kernel_params_buf32[24] = 0;
4868 device_param->kernel_params_buf32[25] = 0;
4869 device_param->kernel_params_buf32[26] = 0;
4870 device_param->kernel_params_buf32[27] = 0;
4871 device_param->kernel_params_buf32[28] = 0;
4872 device_param->kernel_params_buf32[29] = 0;
4873 device_param->kernel_params_buf32[30] = 0;
4874 device_param->kernel_params_buf32[31] = 0;
4875
4876 data.dictfile = dictfile_old;
4877
4878 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4879 }
4880
4881 // hlfmt hashcat
4882
4883 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4884 {
4885 if (data.username == 0)
4886 {
4887 *hashbuf_pos = line_buf;
4888 *hashbuf_len = line_len;
4889 }
4890 else
4891 {
4892 char *pos = line_buf;
4893 int len = line_len;
4894
4895 for (int i = 0; i < line_len; i++, pos++, len--)
4896 {
4897 if (line_buf[i] == data.separator)
4898 {
4899 pos++;
4900
4901 len--;
4902
4903 break;
4904 }
4905 }
4906
4907 *hashbuf_pos = pos;
4908 *hashbuf_len = len;
4909 }
4910 }
4911
4912 static void hlfmt_user_hashcat (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] == data.separator)
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 pwdump
4941
4942 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
4943 {
4944 int sep_cnt = 0;
4945
4946 int sep2_len = 0;
4947 int sep3_len = 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 == 2) sep2_len++;
4959 if (sep_cnt == 3) sep3_len++;
4960 }
4961
4962 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4963
4964 return 0;
4965 }
4966
4967 static void hlfmt_hash_pwdump (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 (data.hash_mode == 1000)
4984 {
4985 if (sep_cnt == 3)
4986 {
4987 if (pos == NULL) pos = line_buf + i;
4988
4989 len++;
4990 }
4991 }
4992 else if (data.hash_mode == 3000)
4993 {
4994 if (sep_cnt == 2)
4995 {
4996 if (pos == NULL) pos = line_buf + i;
4997
4998 len++;
4999 }
5000 }
5001 }
5002
5003 *hashbuf_pos = pos;
5004 *hashbuf_len = len;
5005 }
5006
5007 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5008 {
5009 char *pos = NULL;
5010 int len = 0;
5011
5012 int sep_cnt = 0;
5013
5014 for (int i = 0; i < line_len; i++)
5015 {
5016 if (line_buf[i] == ':')
5017 {
5018 sep_cnt++;
5019
5020 continue;
5021 }
5022
5023 if (sep_cnt == 0)
5024 {
5025 if (pos == NULL) pos = line_buf + i;
5026
5027 len++;
5028 }
5029 }
5030
5031 *userbuf_pos = pos;
5032 *userbuf_len = len;
5033 }
5034
5035 // hlfmt passwd
5036
5037 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5038 {
5039 int sep_cnt = 0;
5040
5041 char sep5_first = 0;
5042 char sep6_first = 0;
5043
5044 for (int i = 0; i < line_len; i++)
5045 {
5046 if (line_buf[i] == ':')
5047 {
5048 sep_cnt++;
5049
5050 continue;
5051 }
5052
5053 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5054 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5055 }
5056
5057 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5058
5059 return 0;
5060 }
5061
5062 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5063 {
5064 char *pos = NULL;
5065 int len = 0;
5066
5067 int sep_cnt = 0;
5068
5069 for (int i = 0; i < line_len; i++)
5070 {
5071 if (line_buf[i] == ':')
5072 {
5073 sep_cnt++;
5074
5075 continue;
5076 }
5077
5078 if (sep_cnt == 1)
5079 {
5080 if (pos == NULL) pos = line_buf + i;
5081
5082 len++;
5083 }
5084 }
5085
5086 *hashbuf_pos = pos;
5087 *hashbuf_len = len;
5088 }
5089
5090 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5091 {
5092 char *pos = NULL;
5093 int len = 0;
5094
5095 int sep_cnt = 0;
5096
5097 for (int i = 0; i < line_len; i++)
5098 {
5099 if (line_buf[i] == ':')
5100 {
5101 sep_cnt++;
5102
5103 continue;
5104 }
5105
5106 if (sep_cnt == 0)
5107 {
5108 if (pos == NULL) pos = line_buf + i;
5109
5110 len++;
5111 }
5112 }
5113
5114 *userbuf_pos = pos;
5115 *userbuf_len = len;
5116 }
5117
5118 // hlfmt shadow
5119
5120 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5121 {
5122 int sep_cnt = 0;
5123
5124 for (int i = 0; i < line_len; i++)
5125 {
5126 if (line_buf[i] == ':') sep_cnt++;
5127 }
5128
5129 if (sep_cnt == 8) return 1;
5130
5131 return 0;
5132 }
5133
5134 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5135 {
5136 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5137 }
5138
5139 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5140 {
5141 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5142 }
5143
5144 // hlfmt main
5145
5146 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5147 {
5148 switch (hashfile_format)
5149 {
5150 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5151 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5152 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5153 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5154 }
5155 }
5156
5157 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5158 {
5159 switch (hashfile_format)
5160 {
5161 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5162 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5163 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5164 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5165 }
5166 }
5167
5168 char *strhlfmt (const uint hashfile_format)
5169 {
5170 switch (hashfile_format)
5171 {
5172 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5173 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5174 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5175 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5176 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5177 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5178 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5179 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5180 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5181 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5182 }
5183
5184 return ((char *) "Unknown");
5185 }
5186
5187 static uint hlfmt_detect (FILE *fp, uint max_check)
5188 {
5189 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5190
5191 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5192 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5193
5194 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5195
5196 uint num_check = 0;
5197
5198 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5199
5200 while (!feof (fp))
5201 {
5202 int line_len = fgetl (fp, line_buf);
5203
5204 if (line_len == 0) continue;
5205
5206 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5207 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5208 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5209
5210 if (num_check == max_check) break;
5211
5212 num_check++;
5213 }
5214
5215 myfree (line_buf);
5216
5217 uint hashlist_format = HLFMT_HASHCAT;
5218
5219 for (int i = 1; i < HLFMTS_CNT; i++)
5220 {
5221 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5222
5223 hashlist_format = i;
5224 }
5225
5226 free (formats_cnt);
5227
5228 return hashlist_format;
5229 }
5230
5231 /**
5232 * some further helper function
5233 */
5234
5235 // wrapper around mymalloc for ADL
5236
5237 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5238 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5239 {
5240 return mymalloc (iSize);
5241 }
5242 #endif
5243
5244 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)
5245 {
5246 u64 collisions = 0;
5247
5248 const uint dgst_pos0 = data.dgst_pos0;
5249 const uint dgst_pos1 = data.dgst_pos1;
5250 const uint dgst_pos2 = data.dgst_pos2;
5251 const uint dgst_pos3 = data.dgst_pos3;
5252
5253 memset (bitmap_a, 0, bitmap_size);
5254 memset (bitmap_b, 0, bitmap_size);
5255 memset (bitmap_c, 0, bitmap_size);
5256 memset (bitmap_d, 0, bitmap_size);
5257
5258 for (uint i = 0; i < digests_cnt; i++)
5259 {
5260 uint *digest_ptr = (uint *) digests_buf_ptr;
5261
5262 digests_buf_ptr += dgst_size;
5263
5264 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5265 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5266 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5267 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5268
5269 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5270 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5271 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5272 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5273
5274 if (bitmap_a[idx0] & val0) collisions++;
5275 if (bitmap_b[idx1] & val1) collisions++;
5276 if (bitmap_c[idx2] & val2) collisions++;
5277 if (bitmap_d[idx3] & val3) collisions++;
5278
5279 bitmap_a[idx0] |= val0;
5280 bitmap_b[idx1] |= val1;
5281 bitmap_c[idx2] |= val2;
5282 bitmap_d[idx3] |= val3;
5283
5284 if (collisions >= collisions_max) return 0x7fffffff;
5285 }
5286
5287 return collisions;
5288 }
5289
5290 /**
5291 * main
5292 */
5293
5294 int main (int argc, char **argv)
5295 {
5296 /**
5297 * To help users a bit
5298 */
5299
5300 char *compute = getenv ("COMPUTE");
5301
5302 if (compute)
5303 {
5304 static char display[100];
5305
5306 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5307
5308 putenv (display);
5309 }
5310 else
5311 {
5312 if (getenv ("DISPLAY") == NULL)
5313 putenv ((char *) "DISPLAY=:0");
5314 }
5315
5316 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5317 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5318
5319 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5320 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5321
5322 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5323 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5324
5325 /**
5326 * Real init
5327 */
5328
5329 memset (&data, 0, sizeof (hc_global_data_t));
5330
5331 time_t proc_start;
5332
5333 time (&proc_start);
5334
5335 data.proc_start = proc_start;
5336
5337 int myargc = argc;
5338 char **myargv = argv;
5339
5340 hc_thread_mutex_init (mux_dispatcher);
5341 hc_thread_mutex_init (mux_counter);
5342 hc_thread_mutex_init (mux_display);
5343 hc_thread_mutex_init (mux_adl);
5344
5345 /**
5346 * commandline parameters
5347 */
5348
5349 uint usage = USAGE;
5350 uint version = VERSION;
5351 uint quiet = QUIET;
5352 uint benchmark = BENCHMARK;
5353 uint benchmark_repeats = BENCHMARK_REPEATS;
5354 uint show = SHOW;
5355 uint left = LEFT;
5356 uint username = USERNAME;
5357 uint remove = REMOVE;
5358 uint remove_timer = REMOVE_TIMER;
5359 u64 skip = SKIP;
5360 u64 limit = LIMIT;
5361 uint keyspace = KEYSPACE;
5362 uint potfile_disable = POTFILE_DISABLE;
5363 uint debug_mode = DEBUG_MODE;
5364 char *debug_file = NULL;
5365 char *induction_dir = NULL;
5366 char *outfile_check_dir = NULL;
5367 uint force = FORCE;
5368 uint runtime = RUNTIME;
5369 uint hash_mode = HASH_MODE;
5370 uint attack_mode = ATTACK_MODE;
5371 uint markov_disable = MARKOV_DISABLE;
5372 uint markov_classic = MARKOV_CLASSIC;
5373 uint markov_threshold = MARKOV_THRESHOLD;
5374 char *markov_hcstat = NULL;
5375 char *outfile = NULL;
5376 uint outfile_format = OUTFILE_FORMAT;
5377 uint outfile_autohex = OUTFILE_AUTOHEX;
5378 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5379 uint restore = RESTORE;
5380 uint restore_timer = RESTORE_TIMER;
5381 uint restore_disable = RESTORE_DISABLE;
5382 uint status = STATUS;
5383 uint status_timer = STATUS_TIMER;
5384 uint status_automat = STATUS_AUTOMAT;
5385 uint loopback = LOOPBACK;
5386 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5387 char *session = NULL;
5388 uint hex_charset = HEX_CHARSET;
5389 uint hex_salt = HEX_SALT;
5390 uint hex_wordlist = HEX_WORDLIST;
5391 uint rp_gen = RP_GEN;
5392 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5393 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5394 uint rp_gen_seed = RP_GEN_SEED;
5395 char *rule_buf_l = (char *) RULE_BUF_L;
5396 char *rule_buf_r = (char *) RULE_BUF_R;
5397 uint increment = INCREMENT;
5398 uint increment_min = INCREMENT_MIN;
5399 uint increment_max = INCREMENT_MAX;
5400 char *cpu_affinity = NULL;
5401 OCL_PTR *ocl = NULL;
5402 char *opencl_devices = NULL;
5403 char *opencl_platforms = NULL;
5404 char *opencl_device_types = NULL;
5405 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5406 char *truecrypt_keyfiles = NULL;
5407 uint workload_profile = WORKLOAD_PROFILE;
5408 uint kernel_accel = KERNEL_ACCEL;
5409 uint kernel_loops = KERNEL_LOOPS;
5410 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5411 #ifdef HAVE_HWMON
5412 uint gpu_temp_abort = GPU_TEMP_ABORT;
5413 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5414 #ifdef HAVE_ADL
5415 uint powertune_enable = POWERTUNE_ENABLE;
5416 #endif
5417 #endif
5418 uint logfile_disable = LOGFILE_DISABLE;
5419 uint segment_size = SEGMENT_SIZE;
5420 uint scrypt_tmto = SCRYPT_TMTO;
5421 char separator = SEPARATOR;
5422 uint bitmap_min = BITMAP_MIN;
5423 uint bitmap_max = BITMAP_MAX;
5424 char *custom_charset_1 = NULL;
5425 char *custom_charset_2 = NULL;
5426 char *custom_charset_3 = NULL;
5427 char *custom_charset_4 = NULL;
5428
5429 #define IDX_HELP 'h'
5430 #define IDX_VERSION 'V'
5431 #define IDX_VERSION_LOWER 'v'
5432 #define IDX_QUIET 0xff02
5433 #define IDX_SHOW 0xff03
5434 #define IDX_LEFT 0xff04
5435 #define IDX_REMOVE 0xff05
5436 #define IDX_REMOVE_TIMER 0xff37
5437 #define IDX_SKIP 's'
5438 #define IDX_LIMIT 'l'
5439 #define IDX_KEYSPACE 0xff35
5440 #define IDX_POTFILE_DISABLE 0xff06
5441 #define IDX_DEBUG_MODE 0xff43
5442 #define IDX_DEBUG_FILE 0xff44
5443 #define IDX_INDUCTION_DIR 0xff46
5444 #define IDX_OUTFILE_CHECK_DIR 0xff47
5445 #define IDX_USERNAME 0xff07
5446 #define IDX_FORCE 0xff08
5447 #define IDX_RUNTIME 0xff09
5448 #define IDX_BENCHMARK 'b'
5449 #define IDX_BENCHMARK_REPEATS 0xff78
5450 #define IDX_HASH_MODE 'm'
5451 #define IDX_ATTACK_MODE 'a'
5452 #define IDX_RP_FILE 'r'
5453 #define IDX_RP_GEN 'g'
5454 #define IDX_RP_GEN_FUNC_MIN 0xff10
5455 #define IDX_RP_GEN_FUNC_MAX 0xff11
5456 #define IDX_RP_GEN_SEED 0xff34
5457 #define IDX_RULE_BUF_L 'j'
5458 #define IDX_RULE_BUF_R 'k'
5459 #define IDX_INCREMENT 'i'
5460 #define IDX_INCREMENT_MIN 0xff12
5461 #define IDX_INCREMENT_MAX 0xff13
5462 #define IDX_OUTFILE 'o'
5463 #define IDX_OUTFILE_FORMAT 0xff14
5464 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5465 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5466 #define IDX_RESTORE 0xff15
5467 #define IDX_RESTORE_DISABLE 0xff27
5468 #define IDX_STATUS 0xff17
5469 #define IDX_STATUS_TIMER 0xff18
5470 #define IDX_STATUS_AUTOMAT 0xff50
5471 #define IDX_LOOPBACK 0xff38
5472 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5473 #define IDX_SESSION 0xff19
5474 #define IDX_HEX_CHARSET 0xff20
5475 #define IDX_HEX_SALT 0xff21
5476 #define IDX_HEX_WORDLIST 0xff40
5477 #define IDX_MARKOV_DISABLE 0xff22
5478 #define IDX_MARKOV_CLASSIC 0xff23
5479 #define IDX_MARKOV_THRESHOLD 't'
5480 #define IDX_MARKOV_HCSTAT 0xff24
5481 #define IDX_CPU_AFFINITY 0xff25
5482 #define IDX_OPENCL_DEVICES 'd'
5483 #define IDX_OPENCL_PLATFORMS 0xff72
5484 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5485 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5486 #define IDX_WORKLOAD_PROFILE 'w'
5487 #define IDX_KERNEL_ACCEL 'n'
5488 #define IDX_KERNEL_LOOPS 'u'
5489 #define IDX_GPU_TEMP_DISABLE 0xff29
5490 #define IDX_GPU_TEMP_ABORT 0xff30
5491 #define IDX_GPU_TEMP_RETAIN 0xff31
5492 #define IDX_POWERTUNE_ENABLE 0xff41
5493 #define IDX_LOGFILE_DISABLE 0xff51
5494 #define IDX_TRUECRYPT_KEYFILES 0xff52
5495 #define IDX_SCRYPT_TMTO 0xff61
5496 #define IDX_SEGMENT_SIZE 'c'
5497 #define IDX_SEPARATOR 'p'
5498 #define IDX_BITMAP_MIN 0xff70
5499 #define IDX_BITMAP_MAX 0xff71
5500 #define IDX_CUSTOM_CHARSET_1 '1'
5501 #define IDX_CUSTOM_CHARSET_2 '2'
5502 #define IDX_CUSTOM_CHARSET_3 '3'
5503 #define IDX_CUSTOM_CHARSET_4 '4'
5504
5505 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5506
5507 struct option long_options[] =
5508 {
5509 {"help", no_argument, 0, IDX_HELP},
5510 {"version", no_argument, 0, IDX_VERSION},
5511 {"quiet", no_argument, 0, IDX_QUIET},
5512 {"show", no_argument, 0, IDX_SHOW},
5513 {"left", no_argument, 0, IDX_LEFT},
5514 {"username", no_argument, 0, IDX_USERNAME},
5515 {"remove", no_argument, 0, IDX_REMOVE},
5516 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5517 {"skip", required_argument, 0, IDX_SKIP},
5518 {"limit", required_argument, 0, IDX_LIMIT},
5519 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5520 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5521 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5522 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5523 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5524 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5525 {"force", no_argument, 0, IDX_FORCE},
5526 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5527 {"benchmark-repeats", required_argument, 0, IDX_BENCHMARK_REPEATS},
5528 {"restore", no_argument, 0, IDX_RESTORE},
5529 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5530 {"status", no_argument, 0, IDX_STATUS},
5531 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5532 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5533 {"loopback", no_argument, 0, IDX_LOOPBACK},
5534 {"weak-hash-threshold",
5535 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5536 {"session", required_argument, 0, IDX_SESSION},
5537 {"runtime", required_argument, 0, IDX_RUNTIME},
5538 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5539 {"generate-rules-func-min",
5540 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5541 {"generate-rules-func-max",
5542 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5543 {"generate-rules-seed",
5544 required_argument, 0, IDX_RP_GEN_SEED},
5545 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5546 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5547 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5548 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5549 {"rules-file", required_argument, 0, IDX_RP_FILE},
5550 {"outfile", required_argument, 0, IDX_OUTFILE},
5551 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5552 {"outfile-autohex-disable",
5553 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5554 {"outfile-check-timer",
5555 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5556 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5557 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5558 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5559 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5560 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5561 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5562 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5563 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5564 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5565 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5566 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5567 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5568 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5569 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5570 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5571 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5572 #ifdef HAVE_HWMON
5573 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5574 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5575 #ifdef HAVE_ADL
5576 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5577 #endif
5578 #endif // HAVE_HWMON
5579 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5580 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5581 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5582 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5583 // deprecated
5584 {"seperator", required_argument, 0, IDX_SEPARATOR},
5585 {"separator", required_argument, 0, IDX_SEPARATOR},
5586 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5587 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5588 {"increment", no_argument, 0, IDX_INCREMENT},
5589 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5590 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5591 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5592 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5593 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5594 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5595
5596 {0, 0, 0, 0}
5597 };
5598
5599 uint rp_files_cnt = 0;
5600
5601 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5602
5603 int option_index = 0;
5604 int c = -1;
5605
5606 optind = 1;
5607 optopt = 0;
5608
5609 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5610 {
5611 switch (c)
5612 {
5613 case IDX_HELP: usage = 1; break;
5614 case IDX_VERSION:
5615 case IDX_VERSION_LOWER: version = 1; break;
5616 case IDX_RESTORE: restore = 1; break;
5617 case IDX_SESSION: session = optarg; break;
5618 case IDX_SHOW: show = 1; break;
5619 case IDX_LEFT: left = 1; break;
5620 case '?': return (-1);
5621 }
5622 }
5623
5624 if (optopt != 0)
5625 {
5626 log_error ("ERROR: Invalid argument specified");
5627
5628 return (-1);
5629 }
5630
5631 /**
5632 * exit functions
5633 */
5634
5635 if (version)
5636 {
5637 log_info ("%s (%s)", VERSION_TAG, VERSION_SUM);
5638
5639 return (0);
5640 }
5641
5642 if (usage)
5643 {
5644 usage_big_print (PROGNAME);
5645
5646 return (0);
5647 }
5648
5649 /**
5650 * session needs to be set, always!
5651 */
5652
5653 if (session == NULL) session = (char *) PROGNAME;
5654
5655 /**
5656 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5657 */
5658
5659 char *exec_path = get_exec_path ();
5660
5661 #ifdef LINUX
5662
5663 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5664 char *resolved_exec_path = realpath (exec_path, NULL);
5665
5666 char *install_dir = get_install_dir (resolved_exec_path);
5667 char *profile_dir = NULL;
5668 char *session_dir = NULL;
5669 char *shared_dir = NULL;
5670
5671 if (strcmp (install_dir, resolved_install_folder) == 0)
5672 {
5673 struct passwd *pw = getpwuid (getuid ());
5674
5675 const char *homedir = pw->pw_dir;
5676
5677 profile_dir = get_profile_dir (homedir);
5678 session_dir = get_session_dir (profile_dir);
5679 shared_dir = strdup (SHARED_FOLDER);
5680
5681 mkdir (profile_dir, 0700);
5682 mkdir (session_dir, 0700);
5683 }
5684 else
5685 {
5686 profile_dir = install_dir;
5687 session_dir = install_dir;
5688 shared_dir = install_dir;
5689 }
5690
5691 myfree (resolved_install_folder);
5692 myfree (resolved_exec_path);
5693
5694 #else
5695
5696 char *install_dir = get_install_dir (exec_path);
5697 char *profile_dir = install_dir;
5698 char *session_dir = install_dir;
5699 char *shared_dir = install_dir;
5700
5701 #endif
5702
5703 data.install_dir = install_dir;
5704 data.profile_dir = profile_dir;
5705 data.session_dir = session_dir;
5706 data.shared_dir = shared_dir;
5707
5708 myfree (exec_path);
5709
5710 /**
5711 * kernel cache, we need to make sure folder exist
5712 */
5713
5714 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5715
5716 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5717
5718 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5719
5720 mkdir (kernels_folder, 0700);
5721
5722 myfree (kernels_folder);
5723
5724 /**
5725 * session
5726 */
5727
5728 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5729
5730 data.session = session;
5731
5732 char *eff_restore_file = (char *) mymalloc (session_size);
5733 char *new_restore_file = (char *) mymalloc (session_size);
5734
5735 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5736 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5737
5738 data.eff_restore_file = eff_restore_file;
5739 data.new_restore_file = new_restore_file;
5740
5741 if (((show == 1) || (left == 1)) && (restore == 1))
5742 {
5743 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5744 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5745
5746 return (-1);
5747 }
5748
5749 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5750 if ((show == 1) || (left == 1))
5751 {
5752 restore_disable = 1;
5753
5754 restore = 0;
5755 }
5756
5757 data.restore_disable = restore_disable;
5758
5759 restore_data_t *rd = init_restore (argc, argv);
5760
5761 data.rd = rd;
5762
5763 /**
5764 * restore file
5765 */
5766
5767 if (restore == 1)
5768 {
5769 read_restore (eff_restore_file, rd);
5770
5771 if (rd->version_bin < RESTORE_MIN)
5772 {
5773 log_error ("ERROR: Incompatible restore-file version");
5774
5775 return (-1);
5776 }
5777
5778 myargc = rd->argc;
5779 myargv = rd->argv;
5780
5781 #ifdef _POSIX
5782 rd->pid = getpid ();
5783 #elif _WIN
5784 rd->pid = GetCurrentProcessId ();
5785 #endif
5786 }
5787
5788 uint hash_mode_chgd = 0;
5789 uint runtime_chgd = 0;
5790 uint kernel_loops_chgd = 0;
5791 uint kernel_accel_chgd = 0;
5792 uint attack_mode_chgd = 0;
5793 uint outfile_format_chgd = 0;
5794 uint rp_gen_seed_chgd = 0;
5795 uint remove_timer_chgd = 0;
5796 uint increment_min_chgd = 0;
5797 uint increment_max_chgd = 0;
5798 uint workload_profile_chgd = 0;
5799 uint opencl_vector_width_chgd = 0;
5800
5801 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5802 uint gpu_temp_retain_chgd = 0;
5803 uint gpu_temp_abort_chgd = 0;
5804 #endif
5805
5806 optind = 1;
5807 optopt = 0;
5808 option_index = 0;
5809
5810 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5811 {
5812 switch (c)
5813 {
5814 //case IDX_HELP: usage = 1; break;
5815 //case IDX_VERSION: version = 1; break;
5816 //case IDX_RESTORE: restore = 1; break;
5817 case IDX_QUIET: quiet = 1; break;
5818 //case IDX_SHOW: show = 1; break;
5819 case IDX_SHOW: break;
5820 //case IDX_LEFT: left = 1; break;
5821 case IDX_LEFT: break;
5822 case IDX_USERNAME: username = 1; break;
5823 case IDX_REMOVE: remove = 1; break;
5824 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5825 remove_timer_chgd = 1; break;
5826 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5827 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5828 case IDX_DEBUG_FILE: debug_file = optarg; break;
5829 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5830 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5831 case IDX_FORCE: force = 1; break;
5832 case IDX_SKIP: skip = atoll (optarg); break;
5833 case IDX_LIMIT: limit = atoll (optarg); break;
5834 case IDX_KEYSPACE: keyspace = 1; break;
5835 case IDX_BENCHMARK: benchmark = 1; break;
5836 case IDX_BENCHMARK_REPEATS: benchmark_repeats = atoi (optarg); break;
5837 case IDX_RESTORE: break;
5838 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5839 case IDX_STATUS: status = 1; break;
5840 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5841 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5842 case IDX_LOOPBACK: loopback = 1; break;
5843 case IDX_WEAK_HASH_THRESHOLD:
5844 weak_hash_threshold = atoi (optarg); break;
5845 //case IDX_SESSION: session = optarg; break;
5846 case IDX_SESSION: break;
5847 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5848 hash_mode_chgd = 1; break;
5849 case IDX_RUNTIME: runtime = atoi (optarg);
5850 runtime_chgd = 1; break;
5851 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5852 attack_mode_chgd = 1; break;
5853 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5854 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5855 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5856 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5857 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5858 rp_gen_seed_chgd = 1; break;
5859 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5860 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5861 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5862 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5863 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5864 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5865 case IDX_OUTFILE: outfile = optarg; break;
5866 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5867 outfile_format_chgd = 1; break;
5868 case IDX_OUTFILE_AUTOHEX_DISABLE:
5869 outfile_autohex = 0; break;
5870 case IDX_OUTFILE_CHECK_TIMER:
5871 outfile_check_timer = atoi (optarg); break;
5872 case IDX_HEX_CHARSET: hex_charset = 1; break;
5873 case IDX_HEX_SALT: hex_salt = 1; break;
5874 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5875 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5876 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5877 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5878 case IDX_OPENCL_DEVICE_TYPES:
5879 opencl_device_types = optarg; break;
5880 case IDX_OPENCL_VECTOR_WIDTH:
5881 opencl_vector_width = atoi (optarg);
5882 opencl_vector_width_chgd = 1; break;
5883 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
5884 workload_profile_chgd = 1; break;
5885 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5886 kernel_accel_chgd = 1; break;
5887 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5888 kernel_loops_chgd = 1; break;
5889 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5890 #ifdef HAVE_HWMON
5891 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5892 #ifdef HAVE_ADL
5893 gpu_temp_abort_chgd = 1;
5894 #endif
5895 break;
5896 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5897 #ifdef HAVE_ADL
5898 gpu_temp_retain_chgd = 1;
5899 #endif
5900 break;
5901 #ifdef HAVE_ADL
5902 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5903 #endif
5904 #endif // HAVE_HWMON
5905 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5906 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5907 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5908 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5909 case IDX_SEPARATOR: separator = optarg[0]; break;
5910 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5911 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5912 case IDX_INCREMENT: increment = 1; break;
5913 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5914 increment_min_chgd = 1; break;
5915 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5916 increment_max_chgd = 1; break;
5917 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5918 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5919 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5920 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5921
5922 default:
5923 log_error ("ERROR: Invalid argument specified");
5924 return (-1);
5925 }
5926 }
5927
5928 if (optopt != 0)
5929 {
5930 log_error ("ERROR: Invalid argument specified");
5931
5932 return (-1);
5933 }
5934
5935 /**
5936 * Inform user things getting started,
5937 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5938 * - we do not need to check algorithm_pos
5939 */
5940
5941 if (quiet == 0)
5942 {
5943 if (benchmark == 1)
5944 {
5945 log_info ("%s %s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5946
5947 log_info ("");
5948 }
5949 else if (restore == 1)
5950 {
5951 log_info ("%s %s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5952
5953 log_info ("");
5954 }
5955 else
5956 {
5957 log_info ("%s %s (%s) starting...", PROGNAME, VERSION_TAG, VERSION_SUM);
5958
5959 log_info ("");
5960 }
5961 }
5962
5963 /**
5964 * sanity check
5965 */
5966
5967 if (attack_mode > 7)
5968 {
5969 log_error ("ERROR: Invalid attack-mode specified");
5970
5971 return (-1);
5972 }
5973
5974 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5975 {
5976 log_error ("ERROR: Invalid runtime specified");
5977
5978 return (-1);
5979 }
5980
5981 if (hash_mode_chgd && hash_mode > 13300) // just added to remove compiler warnings for hash_mode_chgd
5982 {
5983 log_error ("ERROR: Invalid hash-type specified");
5984
5985 return (-1);
5986 }
5987
5988 // renamed hash modes
5989
5990 if (hash_mode_chgd)
5991 {
5992 int n = -1;
5993
5994 switch (hash_mode)
5995 {
5996 case 123: n = 124;
5997 break;
5998 }
5999
6000 if (n >= 0)
6001 {
6002 log_error ("Old -m specified, use -m %d instead", n);
6003
6004 return (-1);
6005 }
6006 }
6007
6008 if (username == 1)
6009 {
6010 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
6011 {
6012 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6013
6014 return (-1);
6015 }
6016 }
6017
6018 if (outfile_format > 16)
6019 {
6020 log_error ("ERROR: Invalid outfile-format specified");
6021
6022 return (-1);
6023 }
6024
6025 if (left == 1)
6026 {
6027 if (outfile_format_chgd == 1)
6028 {
6029 if (outfile_format > 1)
6030 {
6031 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6032
6033 return (-1);
6034 }
6035 }
6036 else
6037 {
6038 outfile_format = OUTFILE_FMT_HASH;
6039 }
6040 }
6041
6042 if (show == 1)
6043 {
6044 if (outfile_format_chgd == 1)
6045 {
6046 if ((outfile_format > 7) && (outfile_format < 16))
6047 {
6048 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6049
6050 return (-1);
6051 }
6052 }
6053 }
6054
6055 if (increment_min < INCREMENT_MIN)
6056 {
6057 log_error ("ERROR: Invalid increment-min specified");
6058
6059 return (-1);
6060 }
6061
6062 if (increment_max > INCREMENT_MAX)
6063 {
6064 log_error ("ERROR: Invalid increment-max specified");
6065
6066 return (-1);
6067 }
6068
6069 if (increment_min > increment_max)
6070 {
6071 log_error ("ERROR: Invalid increment-min specified");
6072
6073 return (-1);
6074 }
6075
6076 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6077 {
6078 log_error ("ERROR: increment is not allowed in attack-mode 0");
6079
6080 return (-1);
6081 }
6082
6083 if ((increment == 0) && (increment_min_chgd == 1))
6084 {
6085 log_error ("ERROR: increment-min is only supported together with increment switch");
6086
6087 return (-1);
6088 }
6089
6090 if ((increment == 0) && (increment_max_chgd == 1))
6091 {
6092 log_error ("ERROR: increment-max is only supported together with increment switch");
6093
6094 return (-1);
6095 }
6096
6097 if (rp_files_cnt && rp_gen)
6098 {
6099 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6100
6101 return (-1);
6102 }
6103
6104 if (rp_files_cnt || rp_gen)
6105 {
6106 if (attack_mode != ATTACK_MODE_STRAIGHT)
6107 {
6108 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6109
6110 return (-1);
6111 }
6112 }
6113
6114 if (rp_gen_func_min > rp_gen_func_max)
6115 {
6116 log_error ("ERROR: Invalid rp-gen-func-min specified");
6117
6118 return (-1);
6119 }
6120
6121 if (kernel_accel_chgd == 1)
6122 {
6123 if (kernel_accel < 1)
6124 {
6125 log_error ("ERROR: Invalid kernel-accel specified");
6126
6127 return (-1);
6128 }
6129
6130 if (kernel_accel > 1024)
6131 {
6132 log_error ("ERROR: Invalid kernel-accel specified");
6133
6134 return (-1);
6135 }
6136 }
6137
6138 if (kernel_loops_chgd == 1)
6139 {
6140 if (kernel_loops < 1)
6141 {
6142 log_error ("ERROR: Invalid kernel-loops specified");
6143
6144 return (-1);
6145 }
6146
6147 if (kernel_loops > 1024)
6148 {
6149 log_error ("ERROR: Invalid kernel-loops specified");
6150
6151 return (-1);
6152 }
6153 }
6154
6155 if ((workload_profile < 1) || (workload_profile > 3))
6156 {
6157 log_error ("ERROR: workload-profile %i not available", workload_profile);
6158
6159 return (-1);
6160 }
6161
6162 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6163 {
6164 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6165
6166 return (-1);
6167 }
6168
6169 if (show == 1 || left == 1)
6170 {
6171 attack_mode = ATTACK_MODE_NONE;
6172
6173 if (remove == 1)
6174 {
6175 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6176
6177 return (-1);
6178 }
6179
6180 if (potfile_disable == 1)
6181 {
6182 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6183
6184 return (-1);
6185 }
6186 }
6187
6188 uint attack_kern = ATTACK_KERN_NONE;
6189
6190 switch (attack_mode)
6191 {
6192 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6193 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6194 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6195 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6196 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6197 }
6198
6199 if (benchmark == 0)
6200 {
6201 if (keyspace == 1)
6202 {
6203 int num_additional_params = 1;
6204
6205 if (attack_kern == ATTACK_KERN_COMBI)
6206 {
6207 num_additional_params = 2;
6208 }
6209
6210 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6211
6212 if (keyspace_wordlist_specified == 0) optind--;
6213 }
6214
6215 if (attack_kern == ATTACK_KERN_NONE)
6216 {
6217 if ((optind + 1) != myargc)
6218 {
6219 usage_mini_print (myargv[0]);
6220
6221 return (-1);
6222 }
6223 }
6224 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6225 {
6226 if ((optind + 1) > myargc)
6227 {
6228 usage_mini_print (myargv[0]);
6229
6230 return (-1);
6231 }
6232 }
6233 else if (attack_kern == ATTACK_KERN_COMBI)
6234 {
6235 if ((optind + 3) != myargc)
6236 {
6237 usage_mini_print (myargv[0]);
6238
6239 return (-1);
6240 }
6241 }
6242 else if (attack_kern == ATTACK_KERN_BF)
6243 {
6244 if ((optind + 1) > myargc)
6245 {
6246 usage_mini_print (myargv[0]);
6247
6248 return (-1);
6249 }
6250 }
6251 else
6252 {
6253 usage_mini_print (myargv[0]);
6254
6255 return (-1);
6256 }
6257 }
6258 else
6259 {
6260 if (myargv[optind] != 0)
6261 {
6262 log_error ("ERROR: Invalid argument for benchmark mode specified");
6263
6264 return (-1);
6265 }
6266
6267 if (attack_mode_chgd == 1)
6268 {
6269 if (attack_mode != ATTACK_MODE_BF)
6270 {
6271 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6272
6273 return (-1);
6274 }
6275 }
6276 }
6277
6278 if (skip != 0 && limit != 0)
6279 {
6280 limit += skip;
6281 }
6282
6283 if (keyspace == 1)
6284 {
6285 if (show == 1)
6286 {
6287 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6288
6289 return (-1);
6290 }
6291 else if (left == 1)
6292 {
6293 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6294
6295 return (-1);
6296 }
6297
6298 potfile_disable = 1;
6299
6300 restore_disable = 1;
6301
6302 restore = 0;
6303
6304 weak_hash_threshold = 0;
6305
6306 quiet = 1;
6307 }
6308
6309 if (remove_timer_chgd == 1)
6310 {
6311 if (remove == 0)
6312 {
6313 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6314
6315 return (-1);
6316 }
6317
6318 if (remove_timer < 1)
6319 {
6320 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6321
6322 return (-1);
6323 }
6324 }
6325
6326 if (loopback == 1)
6327 {
6328 if (attack_mode == ATTACK_MODE_BF)
6329 {
6330 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
6331
6332 return (-1);
6333 }
6334 else if (attack_mode == ATTACK_MODE_STRAIGHT)
6335 {
6336 if ((rp_files_cnt == 0) && (rp_gen == 0))
6337 {
6338 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6339
6340 return (-1);
6341 }
6342 }
6343 }
6344
6345 if (debug_mode > 0)
6346 {
6347 if (attack_mode != ATTACK_MODE_STRAIGHT)
6348 {
6349 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6350
6351 return (-1);
6352 }
6353
6354 if ((rp_files_cnt == 0) && (rp_gen == 0))
6355 {
6356 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6357
6358 return (-1);
6359 }
6360 }
6361
6362 if (debug_mode > 4)
6363 {
6364 log_error ("ERROR: Invalid debug-mode specified");
6365
6366 return (-1);
6367 }
6368
6369 if (debug_file != NULL)
6370 {
6371 if (debug_mode < 1)
6372 {
6373 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6374
6375 return (-1);
6376 }
6377 }
6378
6379 if (induction_dir != NULL)
6380 {
6381 if (attack_mode == ATTACK_MODE_BF)
6382 {
6383 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6384
6385 return (-1);
6386 }
6387 }
6388
6389 if (attack_mode != ATTACK_MODE_STRAIGHT)
6390 {
6391 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6392 {
6393 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6394
6395 return (-1);
6396 }
6397
6398 weak_hash_threshold = 0;
6399 }
6400
6401 /**
6402 * induction directory
6403 */
6404
6405 char *induction_directory = NULL;
6406
6407 if (attack_mode != ATTACK_MODE_BF)
6408 {
6409 if (induction_dir == NULL)
6410 {
6411 induction_directory = (char *) mymalloc (session_size);
6412
6413 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6414
6415 // create induction folder if it does not already exist
6416
6417 if (keyspace == 0)
6418 {
6419 if (rmdir (induction_directory) == -1)
6420 {
6421 if (errno == ENOENT)
6422 {
6423 // good, we can ignore
6424 }
6425 else if (errno == ENOTEMPTY)
6426 {
6427 char *induction_directory_mv = (char *) mymalloc (session_size);
6428
6429 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6430
6431 if (rename (induction_directory, induction_directory_mv) != 0)
6432 {
6433 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6434
6435 return (-1);
6436 }
6437 }
6438 else
6439 {
6440 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6441
6442 return (-1);
6443 }
6444 }
6445
6446 if (mkdir (induction_directory, 0700) == -1)
6447 {
6448 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6449
6450 return (-1);
6451 }
6452 }
6453 }
6454 else
6455 {
6456 induction_directory = induction_dir;
6457 }
6458 }
6459
6460 data.induction_directory = induction_directory;
6461
6462 /**
6463 * loopback
6464 */
6465
6466 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6467
6468 char *loopback_file = (char *) mymalloc (loopback_size);
6469
6470 /**
6471 * tuning db
6472 */
6473
6474 char tuning_db_file[256] = { 0 };
6475
6476 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6477
6478 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6479
6480 /**
6481 * outfile-check directory
6482 */
6483
6484 char *outfile_check_directory = NULL;
6485
6486 if (outfile_check_dir == NULL)
6487 {
6488 outfile_check_directory = (char *) mymalloc (session_size);
6489
6490 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6491 }
6492 else
6493 {
6494 outfile_check_directory = outfile_check_dir;
6495 }
6496
6497 data.outfile_check_directory = outfile_check_directory;
6498
6499 if (keyspace == 0)
6500 {
6501 struct stat outfile_check_stat;
6502
6503 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6504 {
6505 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6506
6507 if (is_dir == 0)
6508 {
6509 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6510
6511 return (-1);
6512 }
6513 }
6514 else if (outfile_check_dir == NULL)
6515 {
6516 if (mkdir (outfile_check_directory, 0700) == -1)
6517 {
6518 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6519
6520 return (-1);
6521 }
6522 }
6523 }
6524
6525 /**
6526 * special other stuff
6527 */
6528
6529 if (hash_mode == 9710)
6530 {
6531 outfile_format = 5;
6532 outfile_format_chgd = 1;
6533 }
6534
6535 if (hash_mode == 9810)
6536 {
6537 outfile_format = 5;
6538 outfile_format_chgd = 1;
6539 }
6540
6541 if (hash_mode == 10410)
6542 {
6543 outfile_format = 5;
6544 outfile_format_chgd = 1;
6545 }
6546
6547 /**
6548 * store stuff
6549 */
6550
6551 data.hash_mode = hash_mode;
6552 data.restore = restore;
6553 data.restore_timer = restore_timer;
6554 data.restore_disable = restore_disable;
6555 data.status = status;
6556 data.status_timer = status_timer;
6557 data.status_automat = status_automat;
6558 data.loopback = loopback;
6559 data.runtime = runtime;
6560 data.remove = remove;
6561 data.remove_timer = remove_timer;
6562 data.debug_mode = debug_mode;
6563 data.debug_file = debug_file;
6564 data.username = username;
6565 data.quiet = quiet;
6566 data.outfile = outfile;
6567 data.outfile_format = outfile_format;
6568 data.outfile_autohex = outfile_autohex;
6569 data.hex_charset = hex_charset;
6570 data.hex_salt = hex_salt;
6571 data.hex_wordlist = hex_wordlist;
6572 data.separator = separator;
6573 data.rp_files = rp_files;
6574 data.rp_files_cnt = rp_files_cnt;
6575 data.rp_gen = rp_gen;
6576 data.rp_gen_seed = rp_gen_seed;
6577 data.force = force;
6578 data.benchmark = benchmark;
6579 data.benchmark_repeats = benchmark_repeats;
6580 data.skip = skip;
6581 data.limit = limit;
6582 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6583 data.powertune_enable = powertune_enable;
6584 #endif
6585 data.logfile_disable = logfile_disable;
6586 data.truecrypt_keyfiles = truecrypt_keyfiles;
6587 data.scrypt_tmto = scrypt_tmto;
6588 data.workload_profile = workload_profile;
6589
6590 /**
6591 * cpu affinity
6592 */
6593
6594 if (cpu_affinity)
6595 {
6596 set_cpu_affinity (cpu_affinity);
6597 }
6598
6599 if (rp_gen_seed_chgd == 0)
6600 {
6601 srand (proc_start);
6602 }
6603 else
6604 {
6605 srand (rp_gen_seed);
6606 }
6607
6608 /**
6609 * logfile init
6610 */
6611
6612 if (logfile_disable == 0)
6613 {
6614 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6615
6616 char *logfile = (char *) mymalloc (logfile_size);
6617
6618 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6619
6620 data.logfile = logfile;
6621
6622 char *topid = logfile_generate_topid ();
6623
6624 data.topid = topid;
6625 }
6626
6627 // logfile_append() checks for logfile_disable internally to make it easier from here
6628
6629 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6630 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6631 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6632 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6633 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6634 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6635 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6636 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6637 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6638 #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));
6639
6640 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6641 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6642 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6643 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6644 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6645 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6646 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6647 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6648
6649 logfile_top_msg ("START");
6650
6651 logfile_top_uint (attack_mode);
6652 logfile_top_uint (attack_kern);
6653 logfile_top_uint (benchmark);
6654 logfile_top_uint (benchmark_repeats);
6655 logfile_top_uint (bitmap_min);
6656 logfile_top_uint (bitmap_max);
6657 logfile_top_uint (debug_mode);
6658 logfile_top_uint (force);
6659 logfile_top_uint (kernel_accel);
6660 logfile_top_uint (kernel_loops);
6661 logfile_top_uint (gpu_temp_disable);
6662 #ifdef HAVE_HWMON
6663 logfile_top_uint (gpu_temp_abort);
6664 logfile_top_uint (gpu_temp_retain);
6665 #endif
6666 logfile_top_uint (hash_mode);
6667 logfile_top_uint (hex_charset);
6668 logfile_top_uint (hex_salt);
6669 logfile_top_uint (hex_wordlist);
6670 logfile_top_uint (increment);
6671 logfile_top_uint (increment_max);
6672 logfile_top_uint (increment_min);
6673 logfile_top_uint (keyspace);
6674 logfile_top_uint (left);
6675 logfile_top_uint (logfile_disable);
6676 logfile_top_uint (loopback);
6677 logfile_top_uint (markov_classic);
6678 logfile_top_uint (markov_disable);
6679 logfile_top_uint (markov_threshold);
6680 logfile_top_uint (outfile_autohex);
6681 logfile_top_uint (outfile_check_timer);
6682 logfile_top_uint (outfile_format);
6683 logfile_top_uint (potfile_disable);
6684 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6685 logfile_top_uint (powertune_enable);
6686 #endif
6687 logfile_top_uint (scrypt_tmto);
6688 logfile_top_uint (quiet);
6689 logfile_top_uint (remove);
6690 logfile_top_uint (remove_timer);
6691 logfile_top_uint (restore);
6692 logfile_top_uint (restore_disable);
6693 logfile_top_uint (restore_timer);
6694 logfile_top_uint (rp_gen);
6695 logfile_top_uint (rp_gen_func_max);
6696 logfile_top_uint (rp_gen_func_min);
6697 logfile_top_uint (rp_gen_seed);
6698 logfile_top_uint (runtime);
6699 logfile_top_uint (segment_size);
6700 logfile_top_uint (show);
6701 logfile_top_uint (status);
6702 logfile_top_uint (status_automat);
6703 logfile_top_uint (status_timer);
6704 logfile_top_uint (usage);
6705 logfile_top_uint (username);
6706 logfile_top_uint (version);
6707 logfile_top_uint (weak_hash_threshold);
6708 logfile_top_uint (workload_profile);
6709 logfile_top_uint64 (limit);
6710 logfile_top_uint64 (skip);
6711 logfile_top_char (separator);
6712 logfile_top_string (cpu_affinity);
6713 logfile_top_string (custom_charset_1);
6714 logfile_top_string (custom_charset_2);
6715 logfile_top_string (custom_charset_3);
6716 logfile_top_string (custom_charset_4);
6717 logfile_top_string (debug_file);
6718 logfile_top_string (opencl_devices);
6719 logfile_top_string (opencl_platforms);
6720 logfile_top_string (opencl_device_types);
6721 logfile_top_uint (opencl_vector_width);
6722 logfile_top_string (induction_dir);
6723 logfile_top_string (markov_hcstat);
6724 logfile_top_string (outfile);
6725 logfile_top_string (outfile_check_dir);
6726 logfile_top_string (rule_buf_l);
6727 logfile_top_string (rule_buf_r);
6728 logfile_top_string (session);
6729 logfile_top_string (truecrypt_keyfiles);
6730
6731 /**
6732 * Init OpenCL library loader
6733 */
6734
6735 if (keyspace == 0)
6736 {
6737 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6738
6739 ocl_init (ocl);
6740
6741 data.ocl = ocl;
6742 }
6743
6744 /**
6745 * OpenCL platform selection
6746 */
6747
6748 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6749
6750 /**
6751 * OpenCL device selection
6752 */
6753
6754 u32 devices_filter = setup_devices_filter (opencl_devices);
6755
6756 /**
6757 * OpenCL device type selection
6758 */
6759
6760 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6761
6762 /**
6763 * benchmark
6764 */
6765
6766 if (benchmark == 1)
6767 {
6768 /**
6769 * disable useless stuff for benchmark
6770 */
6771
6772 status_timer = 0;
6773 restore_timer = 0;
6774 restore_disable = 1;
6775 potfile_disable = 1;
6776 weak_hash_threshold = 0;
6777 gpu_temp_disable = 1;
6778
6779 data.status_timer = status_timer;
6780 data.restore_timer = restore_timer;
6781 data.restore_disable = restore_disable;
6782
6783 /**
6784 * force attack mode to be bruteforce
6785 */
6786
6787 attack_mode = ATTACK_MODE_BF;
6788 attack_kern = ATTACK_KERN_BF;
6789
6790 if (workload_profile_chgd == 0)
6791 {
6792 workload_profile = 3;
6793
6794 data.workload_profile = workload_profile;
6795 }
6796 }
6797
6798 /**
6799 * config
6800 */
6801
6802 uint hash_type = 0;
6803 uint salt_type = 0;
6804 uint attack_exec = 0;
6805 uint opts_type = 0;
6806 uint kern_type = 0;
6807 uint dgst_size = 0;
6808 uint esalt_size = 0;
6809 uint opti_type = 0;
6810 uint dgst_pos0 = -1;
6811 uint dgst_pos1 = -1;
6812 uint dgst_pos2 = -1;
6813 uint dgst_pos3 = -1;
6814
6815 int (*parse_func) (char *, uint, hash_t *);
6816 int (*sort_by_digest) (const void *, const void *);
6817
6818 uint algorithm_pos = 0;
6819 uint algorithm_max = 1;
6820
6821 uint *algorithms = default_benchmark_algorithms;
6822
6823 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6824
6825 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6826 {
6827 /*
6828 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6829 * the following algos are skipped entirely
6830 */
6831
6832 if (algorithm_pos > 0)
6833 {
6834 local_free (rd);
6835
6836 rd = init_restore (argc, argv);
6837
6838 data.rd = rd;
6839 }
6840
6841 /**
6842 * update hash_mode in case of multihash benchmark
6843 */
6844
6845 if (benchmark == 1)
6846 {
6847 if (hash_mode_chgd == 0)
6848 {
6849 hash_mode = algorithms[algorithm_pos];
6850
6851 data.hash_mode = hash_mode;
6852 }
6853
6854 quiet = 1;
6855
6856 data.quiet = quiet;
6857 }
6858
6859 switch (hash_mode)
6860 {
6861 case 0: hash_type = HASH_TYPE_MD5;
6862 salt_type = SALT_TYPE_NONE;
6863 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6864 opts_type = OPTS_TYPE_PT_GENERATE_LE
6865 | OPTS_TYPE_PT_ADD80
6866 | OPTS_TYPE_PT_ADDBITS14;
6867 kern_type = KERN_TYPE_MD5;
6868 dgst_size = DGST_SIZE_4_4;
6869 parse_func = md5_parse_hash;
6870 sort_by_digest = sort_by_digest_4_4;
6871 opti_type = OPTI_TYPE_ZERO_BYTE
6872 | OPTI_TYPE_PRECOMPUTE_INIT
6873 | OPTI_TYPE_PRECOMPUTE_MERKLE
6874 | OPTI_TYPE_MEET_IN_MIDDLE
6875 | OPTI_TYPE_EARLY_SKIP
6876 | OPTI_TYPE_NOT_ITERATED
6877 | OPTI_TYPE_NOT_SALTED
6878 | OPTI_TYPE_RAW_HASH;
6879 dgst_pos0 = 0;
6880 dgst_pos1 = 3;
6881 dgst_pos2 = 2;
6882 dgst_pos3 = 1;
6883 break;
6884
6885 case 10: hash_type = HASH_TYPE_MD5;
6886 salt_type = SALT_TYPE_INTERN;
6887 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6888 opts_type = OPTS_TYPE_PT_GENERATE_LE
6889 | OPTS_TYPE_ST_ADD80
6890 | OPTS_TYPE_ST_ADDBITS14;
6891 kern_type = KERN_TYPE_MD5_PWSLT;
6892 dgst_size = DGST_SIZE_4_4;
6893 parse_func = md5s_parse_hash;
6894 sort_by_digest = sort_by_digest_4_4;
6895 opti_type = OPTI_TYPE_ZERO_BYTE
6896 | OPTI_TYPE_PRECOMPUTE_INIT
6897 | OPTI_TYPE_PRECOMPUTE_MERKLE
6898 | OPTI_TYPE_MEET_IN_MIDDLE
6899 | OPTI_TYPE_EARLY_SKIP
6900 | OPTI_TYPE_NOT_ITERATED
6901 | OPTI_TYPE_APPENDED_SALT
6902 | OPTI_TYPE_RAW_HASH;
6903 dgst_pos0 = 0;
6904 dgst_pos1 = 3;
6905 dgst_pos2 = 2;
6906 dgst_pos3 = 1;
6907 break;
6908
6909 case 11: hash_type = HASH_TYPE_MD5;
6910 salt_type = SALT_TYPE_INTERN;
6911 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6912 opts_type = OPTS_TYPE_PT_GENERATE_LE
6913 | OPTS_TYPE_ST_ADD80
6914 | OPTS_TYPE_ST_ADDBITS14;
6915 kern_type = KERN_TYPE_MD5_PWSLT;
6916 dgst_size = DGST_SIZE_4_4;
6917 parse_func = joomla_parse_hash;
6918 sort_by_digest = sort_by_digest_4_4;
6919 opti_type = OPTI_TYPE_ZERO_BYTE
6920 | OPTI_TYPE_PRECOMPUTE_INIT
6921 | OPTI_TYPE_PRECOMPUTE_MERKLE
6922 | OPTI_TYPE_MEET_IN_MIDDLE
6923 | OPTI_TYPE_EARLY_SKIP
6924 | OPTI_TYPE_NOT_ITERATED
6925 | OPTI_TYPE_APPENDED_SALT
6926 | OPTI_TYPE_RAW_HASH;
6927 dgst_pos0 = 0;
6928 dgst_pos1 = 3;
6929 dgst_pos2 = 2;
6930 dgst_pos3 = 1;
6931 break;
6932
6933 case 12: hash_type = HASH_TYPE_MD5;
6934 salt_type = SALT_TYPE_INTERN;
6935 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6936 opts_type = OPTS_TYPE_PT_GENERATE_LE
6937 | OPTS_TYPE_ST_ADD80
6938 | OPTS_TYPE_ST_ADDBITS14;
6939 kern_type = KERN_TYPE_MD5_PWSLT;
6940 dgst_size = DGST_SIZE_4_4;
6941 parse_func = postgresql_parse_hash;
6942 sort_by_digest = sort_by_digest_4_4;
6943 opti_type = OPTI_TYPE_ZERO_BYTE
6944 | OPTI_TYPE_PRECOMPUTE_INIT
6945 | OPTI_TYPE_PRECOMPUTE_MERKLE
6946 | OPTI_TYPE_MEET_IN_MIDDLE
6947 | OPTI_TYPE_EARLY_SKIP
6948 | OPTI_TYPE_NOT_ITERATED
6949 | OPTI_TYPE_APPENDED_SALT
6950 | OPTI_TYPE_RAW_HASH;
6951 dgst_pos0 = 0;
6952 dgst_pos1 = 3;
6953 dgst_pos2 = 2;
6954 dgst_pos3 = 1;
6955 break;
6956
6957 case 20: hash_type = HASH_TYPE_MD5;
6958 salt_type = SALT_TYPE_INTERN;
6959 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6960 opts_type = OPTS_TYPE_PT_GENERATE_LE
6961 | OPTS_TYPE_PT_ADD80
6962 | OPTS_TYPE_PT_ADDBITS14;
6963 kern_type = KERN_TYPE_MD5_SLTPW;
6964 dgst_size = DGST_SIZE_4_4;
6965 parse_func = md5s_parse_hash;
6966 sort_by_digest = sort_by_digest_4_4;
6967 opti_type = OPTI_TYPE_ZERO_BYTE
6968 | OPTI_TYPE_PRECOMPUTE_INIT
6969 | OPTI_TYPE_PRECOMPUTE_MERKLE
6970 | OPTI_TYPE_EARLY_SKIP
6971 | OPTI_TYPE_NOT_ITERATED
6972 | OPTI_TYPE_PREPENDED_SALT
6973 | OPTI_TYPE_RAW_HASH;
6974 dgst_pos0 = 0;
6975 dgst_pos1 = 3;
6976 dgst_pos2 = 2;
6977 dgst_pos3 = 1;
6978 break;
6979
6980 case 21: hash_type = HASH_TYPE_MD5;
6981 salt_type = SALT_TYPE_INTERN;
6982 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6983 opts_type = OPTS_TYPE_PT_GENERATE_LE
6984 | OPTS_TYPE_PT_ADD80
6985 | OPTS_TYPE_PT_ADDBITS14;
6986 kern_type = KERN_TYPE_MD5_SLTPW;
6987 dgst_size = DGST_SIZE_4_4;
6988 parse_func = osc_parse_hash;
6989 sort_by_digest = sort_by_digest_4_4;
6990 opti_type = OPTI_TYPE_ZERO_BYTE
6991 | OPTI_TYPE_PRECOMPUTE_INIT
6992 | OPTI_TYPE_PRECOMPUTE_MERKLE
6993 | OPTI_TYPE_EARLY_SKIP
6994 | OPTI_TYPE_NOT_ITERATED
6995 | OPTI_TYPE_PREPENDED_SALT
6996 | OPTI_TYPE_RAW_HASH;
6997 dgst_pos0 = 0;
6998 dgst_pos1 = 3;
6999 dgst_pos2 = 2;
7000 dgst_pos3 = 1;
7001 break;
7002
7003 case 22: hash_type = HASH_TYPE_MD5;
7004 salt_type = SALT_TYPE_EMBEDDED;
7005 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7006 opts_type = OPTS_TYPE_PT_GENERATE_LE
7007 | OPTS_TYPE_PT_ADD80
7008 | OPTS_TYPE_PT_ADDBITS14;
7009 kern_type = KERN_TYPE_MD5_SLTPW;
7010 dgst_size = DGST_SIZE_4_4;
7011 parse_func = netscreen_parse_hash;
7012 sort_by_digest = sort_by_digest_4_4;
7013 opti_type = OPTI_TYPE_ZERO_BYTE
7014 | OPTI_TYPE_PRECOMPUTE_INIT
7015 | OPTI_TYPE_PRECOMPUTE_MERKLE
7016 | OPTI_TYPE_EARLY_SKIP
7017 | OPTI_TYPE_NOT_ITERATED
7018 | OPTI_TYPE_PREPENDED_SALT
7019 | OPTI_TYPE_RAW_HASH;
7020 dgst_pos0 = 0;
7021 dgst_pos1 = 3;
7022 dgst_pos2 = 2;
7023 dgst_pos3 = 1;
7024 break;
7025
7026 case 23: hash_type = HASH_TYPE_MD5;
7027 salt_type = SALT_TYPE_EMBEDDED;
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_MD5_SLTPW;
7033 dgst_size = DGST_SIZE_4_4;
7034 parse_func = skype_parse_hash;
7035 sort_by_digest = sort_by_digest_4_4;
7036 opti_type = OPTI_TYPE_ZERO_BYTE
7037 | OPTI_TYPE_PRECOMPUTE_INIT
7038 | OPTI_TYPE_PRECOMPUTE_MERKLE
7039 | OPTI_TYPE_EARLY_SKIP
7040 | OPTI_TYPE_NOT_ITERATED
7041 | OPTI_TYPE_PREPENDED_SALT
7042 | OPTI_TYPE_RAW_HASH;
7043 dgst_pos0 = 0;
7044 dgst_pos1 = 3;
7045 dgst_pos2 = 2;
7046 dgst_pos3 = 1;
7047 break;
7048
7049 case 30: hash_type = HASH_TYPE_MD5;
7050 salt_type = SALT_TYPE_INTERN;
7051 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7052 opts_type = OPTS_TYPE_PT_GENERATE_LE
7053 | OPTS_TYPE_PT_UNICODE
7054 | OPTS_TYPE_ST_ADD80
7055 | OPTS_TYPE_ST_ADDBITS14;
7056 kern_type = KERN_TYPE_MD5_PWUSLT;
7057 dgst_size = DGST_SIZE_4_4;
7058 parse_func = md5s_parse_hash;
7059 sort_by_digest = sort_by_digest_4_4;
7060 opti_type = OPTI_TYPE_ZERO_BYTE
7061 | OPTI_TYPE_PRECOMPUTE_INIT
7062 | OPTI_TYPE_PRECOMPUTE_MERKLE
7063 | OPTI_TYPE_MEET_IN_MIDDLE
7064 | OPTI_TYPE_EARLY_SKIP
7065 | OPTI_TYPE_NOT_ITERATED
7066 | OPTI_TYPE_APPENDED_SALT
7067 | OPTI_TYPE_RAW_HASH;
7068 dgst_pos0 = 0;
7069 dgst_pos1 = 3;
7070 dgst_pos2 = 2;
7071 dgst_pos3 = 1;
7072 break;
7073
7074 case 40: hash_type = HASH_TYPE_MD5;
7075 salt_type = SALT_TYPE_INTERN;
7076 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7077 opts_type = OPTS_TYPE_PT_GENERATE_LE
7078 | OPTS_TYPE_PT_ADD80
7079 | OPTS_TYPE_PT_ADDBITS14
7080 | OPTS_TYPE_PT_UNICODE;
7081 kern_type = KERN_TYPE_MD5_SLTPWU;
7082 dgst_size = DGST_SIZE_4_4;
7083 parse_func = md5s_parse_hash;
7084 sort_by_digest = sort_by_digest_4_4;
7085 opti_type = OPTI_TYPE_ZERO_BYTE
7086 | OPTI_TYPE_PRECOMPUTE_INIT
7087 | OPTI_TYPE_PRECOMPUTE_MERKLE
7088 | OPTI_TYPE_EARLY_SKIP
7089 | OPTI_TYPE_NOT_ITERATED
7090 | OPTI_TYPE_PREPENDED_SALT
7091 | OPTI_TYPE_RAW_HASH;
7092 dgst_pos0 = 0;
7093 dgst_pos1 = 3;
7094 dgst_pos2 = 2;
7095 dgst_pos3 = 1;
7096 break;
7097
7098 case 50: hash_type = HASH_TYPE_MD5;
7099 salt_type = SALT_TYPE_INTERN;
7100 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7101 opts_type = OPTS_TYPE_PT_GENERATE_LE
7102 | OPTS_TYPE_ST_ADD80
7103 | OPTS_TYPE_ST_ADDBITS14;
7104 kern_type = KERN_TYPE_HMACMD5_PW;
7105 dgst_size = DGST_SIZE_4_4;
7106 parse_func = hmacmd5_parse_hash;
7107 sort_by_digest = sort_by_digest_4_4;
7108 opti_type = OPTI_TYPE_ZERO_BYTE
7109 | OPTI_TYPE_NOT_ITERATED;
7110 dgst_pos0 = 0;
7111 dgst_pos1 = 3;
7112 dgst_pos2 = 2;
7113 dgst_pos3 = 1;
7114 break;
7115
7116 case 60: hash_type = HASH_TYPE_MD5;
7117 salt_type = SALT_TYPE_INTERN;
7118 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7119 opts_type = OPTS_TYPE_PT_GENERATE_LE
7120 | OPTS_TYPE_PT_ADD80
7121 | OPTS_TYPE_PT_ADDBITS14;
7122 kern_type = KERN_TYPE_HMACMD5_SLT;
7123 dgst_size = DGST_SIZE_4_4;
7124 parse_func = hmacmd5_parse_hash;
7125 sort_by_digest = sort_by_digest_4_4;
7126 opti_type = OPTI_TYPE_ZERO_BYTE
7127 | OPTI_TYPE_NOT_ITERATED;
7128 dgst_pos0 = 0;
7129 dgst_pos1 = 3;
7130 dgst_pos2 = 2;
7131 dgst_pos3 = 1;
7132 break;
7133
7134 case 100: hash_type = HASH_TYPE_SHA1;
7135 salt_type = SALT_TYPE_NONE;
7136 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7137 opts_type = OPTS_TYPE_PT_GENERATE_BE
7138 | OPTS_TYPE_PT_ADD80
7139 | OPTS_TYPE_PT_ADDBITS15;
7140 kern_type = KERN_TYPE_SHA1;
7141 dgst_size = DGST_SIZE_4_5;
7142 parse_func = sha1_parse_hash;
7143 sort_by_digest = sort_by_digest_4_5;
7144 opti_type = OPTI_TYPE_ZERO_BYTE
7145 | OPTI_TYPE_PRECOMPUTE_INIT
7146 | OPTI_TYPE_PRECOMPUTE_MERKLE
7147 | OPTI_TYPE_EARLY_SKIP
7148 | OPTI_TYPE_NOT_ITERATED
7149 | OPTI_TYPE_NOT_SALTED
7150 | OPTI_TYPE_RAW_HASH;
7151 dgst_pos0 = 3;
7152 dgst_pos1 = 4;
7153 dgst_pos2 = 2;
7154 dgst_pos3 = 1;
7155 break;
7156
7157 case 101: hash_type = HASH_TYPE_SHA1;
7158 salt_type = SALT_TYPE_NONE;
7159 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7160 opts_type = OPTS_TYPE_PT_GENERATE_BE
7161 | OPTS_TYPE_PT_ADD80
7162 | OPTS_TYPE_PT_ADDBITS15;
7163 kern_type = KERN_TYPE_SHA1;
7164 dgst_size = DGST_SIZE_4_5;
7165 parse_func = sha1b64_parse_hash;
7166 sort_by_digest = sort_by_digest_4_5;
7167 opti_type = OPTI_TYPE_ZERO_BYTE
7168 | OPTI_TYPE_PRECOMPUTE_INIT
7169 | OPTI_TYPE_PRECOMPUTE_MERKLE
7170 | OPTI_TYPE_EARLY_SKIP
7171 | OPTI_TYPE_NOT_ITERATED
7172 | OPTI_TYPE_NOT_SALTED
7173 | OPTI_TYPE_RAW_HASH;
7174 dgst_pos0 = 3;
7175 dgst_pos1 = 4;
7176 dgst_pos2 = 2;
7177 dgst_pos3 = 1;
7178 break;
7179
7180 case 110: hash_type = HASH_TYPE_SHA1;
7181 salt_type = SALT_TYPE_INTERN;
7182 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7183 opts_type = OPTS_TYPE_PT_GENERATE_BE
7184 | OPTS_TYPE_ST_ADD80
7185 | OPTS_TYPE_ST_ADDBITS15;
7186 kern_type = KERN_TYPE_SHA1_PWSLT;
7187 dgst_size = DGST_SIZE_4_5;
7188 parse_func = sha1s_parse_hash;
7189 sort_by_digest = sort_by_digest_4_5;
7190 opti_type = OPTI_TYPE_ZERO_BYTE
7191 | OPTI_TYPE_PRECOMPUTE_INIT
7192 | OPTI_TYPE_PRECOMPUTE_MERKLE
7193 | OPTI_TYPE_EARLY_SKIP
7194 | OPTI_TYPE_NOT_ITERATED
7195 | OPTI_TYPE_APPENDED_SALT
7196 | OPTI_TYPE_RAW_HASH;
7197 dgst_pos0 = 3;
7198 dgst_pos1 = 4;
7199 dgst_pos2 = 2;
7200 dgst_pos3 = 1;
7201 break;
7202
7203 case 111: hash_type = HASH_TYPE_SHA1;
7204 salt_type = SALT_TYPE_EMBEDDED;
7205 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7206 opts_type = OPTS_TYPE_PT_GENERATE_BE
7207 | OPTS_TYPE_ST_ADD80
7208 | OPTS_TYPE_ST_ADDBITS15;
7209 kern_type = KERN_TYPE_SHA1_PWSLT;
7210 dgst_size = DGST_SIZE_4_5;
7211 parse_func = sha1b64s_parse_hash;
7212 sort_by_digest = sort_by_digest_4_5;
7213 opti_type = OPTI_TYPE_ZERO_BYTE
7214 | OPTI_TYPE_PRECOMPUTE_INIT
7215 | OPTI_TYPE_PRECOMPUTE_MERKLE
7216 | OPTI_TYPE_EARLY_SKIP
7217 | OPTI_TYPE_NOT_ITERATED
7218 | OPTI_TYPE_APPENDED_SALT
7219 | OPTI_TYPE_RAW_HASH;
7220 dgst_pos0 = 3;
7221 dgst_pos1 = 4;
7222 dgst_pos2 = 2;
7223 dgst_pos3 = 1;
7224 break;
7225
7226 case 112: hash_type = HASH_TYPE_SHA1;
7227 salt_type = SALT_TYPE_INTERN;
7228 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7229 opts_type = OPTS_TYPE_PT_GENERATE_BE
7230 | OPTS_TYPE_ST_ADD80
7231 | OPTS_TYPE_ST_ADDBITS15
7232 | OPTS_TYPE_ST_HEX;
7233 kern_type = KERN_TYPE_SHA1_PWSLT;
7234 dgst_size = DGST_SIZE_4_5;
7235 parse_func = oracles_parse_hash;
7236 sort_by_digest = sort_by_digest_4_5;
7237 opti_type = OPTI_TYPE_ZERO_BYTE
7238 | OPTI_TYPE_PRECOMPUTE_INIT
7239 | OPTI_TYPE_PRECOMPUTE_MERKLE
7240 | OPTI_TYPE_EARLY_SKIP
7241 | OPTI_TYPE_NOT_ITERATED
7242 | OPTI_TYPE_APPENDED_SALT
7243 | OPTI_TYPE_RAW_HASH;
7244 dgst_pos0 = 3;
7245 dgst_pos1 = 4;
7246 dgst_pos2 = 2;
7247 dgst_pos3 = 1;
7248 break;
7249
7250 case 120: hash_type = HASH_TYPE_SHA1;
7251 salt_type = SALT_TYPE_INTERN;
7252 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7253 opts_type = OPTS_TYPE_PT_GENERATE_BE
7254 | OPTS_TYPE_PT_ADD80
7255 | OPTS_TYPE_PT_ADDBITS15;
7256 kern_type = KERN_TYPE_SHA1_SLTPW;
7257 dgst_size = DGST_SIZE_4_5;
7258 parse_func = sha1s_parse_hash;
7259 sort_by_digest = sort_by_digest_4_5;
7260 opti_type = OPTI_TYPE_ZERO_BYTE
7261 | OPTI_TYPE_PRECOMPUTE_INIT
7262 | OPTI_TYPE_PRECOMPUTE_MERKLE
7263 | OPTI_TYPE_EARLY_SKIP
7264 | OPTI_TYPE_NOT_ITERATED
7265 | OPTI_TYPE_PREPENDED_SALT
7266 | OPTI_TYPE_RAW_HASH;
7267 dgst_pos0 = 3;
7268 dgst_pos1 = 4;
7269 dgst_pos2 = 2;
7270 dgst_pos3 = 1;
7271 break;
7272
7273 case 121: hash_type = HASH_TYPE_SHA1;
7274 salt_type = SALT_TYPE_INTERN;
7275 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7276 opts_type = OPTS_TYPE_PT_GENERATE_BE
7277 | OPTS_TYPE_PT_ADD80
7278 | OPTS_TYPE_PT_ADDBITS15
7279 | OPTS_TYPE_ST_LOWER;
7280 kern_type = KERN_TYPE_SHA1_SLTPW;
7281 dgst_size = DGST_SIZE_4_5;
7282 parse_func = smf_parse_hash;
7283 sort_by_digest = sort_by_digest_4_5;
7284 opti_type = OPTI_TYPE_ZERO_BYTE
7285 | OPTI_TYPE_PRECOMPUTE_INIT
7286 | OPTI_TYPE_PRECOMPUTE_MERKLE
7287 | OPTI_TYPE_EARLY_SKIP
7288 | OPTI_TYPE_NOT_ITERATED
7289 | OPTI_TYPE_PREPENDED_SALT
7290 | OPTI_TYPE_RAW_HASH;
7291 dgst_pos0 = 3;
7292 dgst_pos1 = 4;
7293 dgst_pos2 = 2;
7294 dgst_pos3 = 1;
7295 break;
7296
7297 case 122: hash_type = HASH_TYPE_SHA1;
7298 salt_type = SALT_TYPE_EMBEDDED;
7299 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7300 opts_type = OPTS_TYPE_PT_GENERATE_BE
7301 | OPTS_TYPE_PT_ADD80
7302 | OPTS_TYPE_PT_ADDBITS15
7303 | OPTS_TYPE_ST_HEX;
7304 kern_type = KERN_TYPE_SHA1_SLTPW;
7305 dgst_size = DGST_SIZE_4_5;
7306 parse_func = osx1_parse_hash;
7307 sort_by_digest = sort_by_digest_4_5;
7308 opti_type = OPTI_TYPE_ZERO_BYTE
7309 | OPTI_TYPE_PRECOMPUTE_INIT
7310 | OPTI_TYPE_PRECOMPUTE_MERKLE
7311 | OPTI_TYPE_EARLY_SKIP
7312 | OPTI_TYPE_NOT_ITERATED
7313 | OPTI_TYPE_PREPENDED_SALT
7314 | OPTI_TYPE_RAW_HASH;
7315 dgst_pos0 = 3;
7316 dgst_pos1 = 4;
7317 dgst_pos2 = 2;
7318 dgst_pos3 = 1;
7319 break;
7320
7321 case 124: hash_type = HASH_TYPE_SHA1;
7322 salt_type = SALT_TYPE_EMBEDDED;
7323 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7324 opts_type = OPTS_TYPE_PT_GENERATE_BE
7325 | OPTS_TYPE_PT_ADD80
7326 | OPTS_TYPE_PT_ADDBITS15;
7327 kern_type = KERN_TYPE_SHA1_SLTPW;
7328 dgst_size = DGST_SIZE_4_5;
7329 parse_func = djangosha1_parse_hash;
7330 sort_by_digest = sort_by_digest_4_5;
7331 opti_type = OPTI_TYPE_ZERO_BYTE
7332 | OPTI_TYPE_PRECOMPUTE_INIT
7333 | OPTI_TYPE_PRECOMPUTE_MERKLE
7334 | OPTI_TYPE_EARLY_SKIP
7335 | OPTI_TYPE_NOT_ITERATED
7336 | OPTI_TYPE_PREPENDED_SALT
7337 | OPTI_TYPE_RAW_HASH;
7338 dgst_pos0 = 3;
7339 dgst_pos1 = 4;
7340 dgst_pos2 = 2;
7341 dgst_pos3 = 1;
7342 break;
7343
7344 case 130: hash_type = HASH_TYPE_SHA1;
7345 salt_type = SALT_TYPE_INTERN;
7346 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7347 opts_type = OPTS_TYPE_PT_GENERATE_BE
7348 | OPTS_TYPE_PT_UNICODE
7349 | OPTS_TYPE_ST_ADD80
7350 | OPTS_TYPE_ST_ADDBITS15;
7351 kern_type = KERN_TYPE_SHA1_PWUSLT;
7352 dgst_size = DGST_SIZE_4_5;
7353 parse_func = sha1s_parse_hash;
7354 sort_by_digest = sort_by_digest_4_5;
7355 opti_type = OPTI_TYPE_ZERO_BYTE
7356 | OPTI_TYPE_PRECOMPUTE_INIT
7357 | OPTI_TYPE_PRECOMPUTE_MERKLE
7358 | OPTI_TYPE_EARLY_SKIP
7359 | OPTI_TYPE_NOT_ITERATED
7360 | OPTI_TYPE_APPENDED_SALT
7361 | OPTI_TYPE_RAW_HASH;
7362 dgst_pos0 = 3;
7363 dgst_pos1 = 4;
7364 dgst_pos2 = 2;
7365 dgst_pos3 = 1;
7366 break;
7367
7368 case 131: hash_type = HASH_TYPE_SHA1;
7369 salt_type = SALT_TYPE_EMBEDDED;
7370 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7371 opts_type = OPTS_TYPE_PT_GENERATE_BE
7372 | OPTS_TYPE_PT_UNICODE
7373 | OPTS_TYPE_PT_UPPER
7374 | OPTS_TYPE_ST_ADD80
7375 | OPTS_TYPE_ST_ADDBITS15
7376 | OPTS_TYPE_ST_HEX;
7377 kern_type = KERN_TYPE_SHA1_PWUSLT;
7378 dgst_size = DGST_SIZE_4_5;
7379 parse_func = mssql2000_parse_hash;
7380 sort_by_digest = sort_by_digest_4_5;
7381 opti_type = OPTI_TYPE_ZERO_BYTE
7382 | OPTI_TYPE_PRECOMPUTE_INIT
7383 | OPTI_TYPE_PRECOMPUTE_MERKLE
7384 | OPTI_TYPE_EARLY_SKIP
7385 | OPTI_TYPE_NOT_ITERATED
7386 | OPTI_TYPE_APPENDED_SALT
7387 | OPTI_TYPE_RAW_HASH;
7388 dgst_pos0 = 3;
7389 dgst_pos1 = 4;
7390 dgst_pos2 = 2;
7391 dgst_pos3 = 1;
7392 break;
7393
7394 case 132: hash_type = HASH_TYPE_SHA1;
7395 salt_type = SALT_TYPE_EMBEDDED;
7396 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7397 opts_type = OPTS_TYPE_PT_GENERATE_BE
7398 | OPTS_TYPE_PT_UNICODE
7399 | OPTS_TYPE_ST_ADD80
7400 | OPTS_TYPE_ST_ADDBITS15
7401 | OPTS_TYPE_ST_HEX;
7402 kern_type = KERN_TYPE_SHA1_PWUSLT;
7403 dgst_size = DGST_SIZE_4_5;
7404 parse_func = mssql2005_parse_hash;
7405 sort_by_digest = sort_by_digest_4_5;
7406 opti_type = OPTI_TYPE_ZERO_BYTE
7407 | OPTI_TYPE_PRECOMPUTE_INIT
7408 | OPTI_TYPE_PRECOMPUTE_MERKLE
7409 | OPTI_TYPE_EARLY_SKIP
7410 | OPTI_TYPE_NOT_ITERATED
7411 | OPTI_TYPE_APPENDED_SALT
7412 | OPTI_TYPE_RAW_HASH;
7413 dgst_pos0 = 3;
7414 dgst_pos1 = 4;
7415 dgst_pos2 = 2;
7416 dgst_pos3 = 1;
7417 break;
7418
7419 case 133: hash_type = HASH_TYPE_SHA1;
7420 salt_type = SALT_TYPE_EMBEDDED;
7421 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7422 opts_type = OPTS_TYPE_PT_GENERATE_BE
7423 | OPTS_TYPE_PT_UNICODE
7424 | OPTS_TYPE_ST_ADD80
7425 | OPTS_TYPE_ST_ADDBITS15;
7426 kern_type = KERN_TYPE_SHA1_PWUSLT;
7427 dgst_size = DGST_SIZE_4_5;
7428 parse_func = peoplesoft_parse_hash;
7429 sort_by_digest = sort_by_digest_4_5;
7430 opti_type = OPTI_TYPE_ZERO_BYTE
7431 | OPTI_TYPE_PRECOMPUTE_INIT
7432 | OPTI_TYPE_PRECOMPUTE_MERKLE
7433 | OPTI_TYPE_EARLY_SKIP
7434 | OPTI_TYPE_NOT_ITERATED
7435 | OPTI_TYPE_APPENDED_SALT
7436 | OPTI_TYPE_RAW_HASH;
7437 dgst_pos0 = 3;
7438 dgst_pos1 = 4;
7439 dgst_pos2 = 2;
7440 dgst_pos3 = 1;
7441 break;
7442
7443 case 140: hash_type = HASH_TYPE_SHA1;
7444 salt_type = SALT_TYPE_INTERN;
7445 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7446 opts_type = OPTS_TYPE_PT_GENERATE_BE
7447 | OPTS_TYPE_PT_ADD80
7448 | OPTS_TYPE_PT_ADDBITS15
7449 | OPTS_TYPE_PT_UNICODE;
7450 kern_type = KERN_TYPE_SHA1_SLTPWU;
7451 dgst_size = DGST_SIZE_4_5;
7452 parse_func = sha1s_parse_hash;
7453 sort_by_digest = sort_by_digest_4_5;
7454 opti_type = OPTI_TYPE_ZERO_BYTE
7455 | OPTI_TYPE_PRECOMPUTE_INIT
7456 | OPTI_TYPE_PRECOMPUTE_MERKLE
7457 | OPTI_TYPE_EARLY_SKIP
7458 | OPTI_TYPE_NOT_ITERATED
7459 | OPTI_TYPE_PREPENDED_SALT
7460 | OPTI_TYPE_RAW_HASH;
7461 dgst_pos0 = 3;
7462 dgst_pos1 = 4;
7463 dgst_pos2 = 2;
7464 dgst_pos3 = 1;
7465 break;
7466
7467 case 141: hash_type = HASH_TYPE_SHA1;
7468 salt_type = SALT_TYPE_EMBEDDED;
7469 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7470 opts_type = OPTS_TYPE_PT_GENERATE_BE
7471 | OPTS_TYPE_PT_ADD80
7472 | OPTS_TYPE_PT_ADDBITS15
7473 | OPTS_TYPE_PT_UNICODE
7474 | OPTS_TYPE_ST_BASE64;
7475 kern_type = KERN_TYPE_SHA1_SLTPWU;
7476 dgst_size = DGST_SIZE_4_5;
7477 parse_func = episerver_parse_hash;
7478 sort_by_digest = sort_by_digest_4_5;
7479 opti_type = OPTI_TYPE_ZERO_BYTE
7480 | OPTI_TYPE_PRECOMPUTE_INIT
7481 | OPTI_TYPE_PRECOMPUTE_MERKLE
7482 | OPTI_TYPE_EARLY_SKIP
7483 | OPTI_TYPE_NOT_ITERATED
7484 | OPTI_TYPE_PREPENDED_SALT
7485 | OPTI_TYPE_RAW_HASH;
7486 dgst_pos0 = 3;
7487 dgst_pos1 = 4;
7488 dgst_pos2 = 2;
7489 dgst_pos3 = 1;
7490 break;
7491
7492 case 150: hash_type = HASH_TYPE_SHA1;
7493 salt_type = SALT_TYPE_INTERN;
7494 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7495 opts_type = OPTS_TYPE_PT_GENERATE_BE
7496 | OPTS_TYPE_ST_ADD80
7497 | OPTS_TYPE_ST_ADDBITS15;
7498 kern_type = KERN_TYPE_HMACSHA1_PW;
7499 dgst_size = DGST_SIZE_4_5;
7500 parse_func = hmacsha1_parse_hash;
7501 sort_by_digest = sort_by_digest_4_5;
7502 opti_type = OPTI_TYPE_ZERO_BYTE
7503 | OPTI_TYPE_NOT_ITERATED;
7504 dgst_pos0 = 3;
7505 dgst_pos1 = 4;
7506 dgst_pos2 = 2;
7507 dgst_pos3 = 1;
7508 break;
7509
7510 case 160: hash_type = HASH_TYPE_SHA1;
7511 salt_type = SALT_TYPE_INTERN;
7512 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7513 opts_type = OPTS_TYPE_PT_GENERATE_BE
7514 | OPTS_TYPE_PT_ADD80
7515 | OPTS_TYPE_PT_ADDBITS15;
7516 kern_type = KERN_TYPE_HMACSHA1_SLT;
7517 dgst_size = DGST_SIZE_4_5;
7518 parse_func = hmacsha1_parse_hash;
7519 sort_by_digest = sort_by_digest_4_5;
7520 opti_type = OPTI_TYPE_ZERO_BYTE
7521 | OPTI_TYPE_NOT_ITERATED;
7522 dgst_pos0 = 3;
7523 dgst_pos1 = 4;
7524 dgst_pos2 = 2;
7525 dgst_pos3 = 1;
7526 break;
7527
7528 case 190: hash_type = HASH_TYPE_SHA1;
7529 salt_type = SALT_TYPE_NONE;
7530 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7531 opts_type = OPTS_TYPE_PT_GENERATE_BE
7532 | OPTS_TYPE_PT_ADD80
7533 | OPTS_TYPE_PT_ADDBITS15;
7534 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7535 dgst_size = DGST_SIZE_4_5;
7536 parse_func = sha1linkedin_parse_hash;
7537 sort_by_digest = sort_by_digest_4_5;
7538 opti_type = OPTI_TYPE_ZERO_BYTE
7539 | OPTI_TYPE_PRECOMPUTE_INIT
7540 | OPTI_TYPE_EARLY_SKIP
7541 | OPTI_TYPE_NOT_ITERATED
7542 | OPTI_TYPE_NOT_SALTED;
7543 dgst_pos0 = 0;
7544 dgst_pos1 = 4;
7545 dgst_pos2 = 3;
7546 dgst_pos3 = 2;
7547 break;
7548
7549 case 200: hash_type = HASH_TYPE_MYSQL;
7550 salt_type = SALT_TYPE_NONE;
7551 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7552 opts_type = 0;
7553 kern_type = KERN_TYPE_MYSQL;
7554 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7555 parse_func = mysql323_parse_hash;
7556 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7557 opti_type = OPTI_TYPE_ZERO_BYTE;
7558 dgst_pos0 = 0;
7559 dgst_pos1 = 1;
7560 dgst_pos2 = 2;
7561 dgst_pos3 = 3;
7562 break;
7563
7564 case 300: hash_type = HASH_TYPE_SHA1;
7565 salt_type = SALT_TYPE_NONE;
7566 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7567 opts_type = OPTS_TYPE_PT_GENERATE_BE
7568 | OPTS_TYPE_PT_ADD80
7569 | OPTS_TYPE_PT_ADDBITS15;
7570 kern_type = KERN_TYPE_MYSQL41;
7571 dgst_size = DGST_SIZE_4_5;
7572 parse_func = sha1_parse_hash;
7573 sort_by_digest = sort_by_digest_4_5;
7574 opti_type = OPTI_TYPE_ZERO_BYTE
7575 | OPTI_TYPE_PRECOMPUTE_INIT
7576 | OPTI_TYPE_PRECOMPUTE_MERKLE
7577 | OPTI_TYPE_EARLY_SKIP
7578 | OPTI_TYPE_NOT_ITERATED
7579 | OPTI_TYPE_NOT_SALTED;
7580 dgst_pos0 = 3;
7581 dgst_pos1 = 4;
7582 dgst_pos2 = 2;
7583 dgst_pos3 = 1;
7584 break;
7585
7586 case 400: hash_type = HASH_TYPE_MD5;
7587 salt_type = SALT_TYPE_EMBEDDED;
7588 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7589 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7590 kern_type = KERN_TYPE_PHPASS;
7591 dgst_size = DGST_SIZE_4_4;
7592 parse_func = phpass_parse_hash;
7593 sort_by_digest = sort_by_digest_4_4;
7594 opti_type = OPTI_TYPE_ZERO_BYTE;
7595 dgst_pos0 = 0;
7596 dgst_pos1 = 1;
7597 dgst_pos2 = 2;
7598 dgst_pos3 = 3;
7599 break;
7600
7601 case 500: hash_type = HASH_TYPE_MD5;
7602 salt_type = SALT_TYPE_EMBEDDED;
7603 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7604 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7605 kern_type = KERN_TYPE_MD5CRYPT;
7606 dgst_size = DGST_SIZE_4_4;
7607 parse_func = md5crypt_parse_hash;
7608 sort_by_digest = sort_by_digest_4_4;
7609 opti_type = OPTI_TYPE_ZERO_BYTE;
7610 dgst_pos0 = 0;
7611 dgst_pos1 = 1;
7612 dgst_pos2 = 2;
7613 dgst_pos3 = 3;
7614 break;
7615
7616 case 501: hash_type = HASH_TYPE_MD5;
7617 salt_type = SALT_TYPE_EMBEDDED;
7618 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7619 opts_type = OPTS_TYPE_PT_GENERATE_LE
7620 | OPTS_TYPE_HASH_COPY;
7621 kern_type = KERN_TYPE_MD5CRYPT;
7622 dgst_size = DGST_SIZE_4_4;
7623 parse_func = juniper_parse_hash;
7624 sort_by_digest = sort_by_digest_4_4;
7625 opti_type = OPTI_TYPE_ZERO_BYTE;
7626 dgst_pos0 = 0;
7627 dgst_pos1 = 1;
7628 dgst_pos2 = 2;
7629 dgst_pos3 = 3;
7630 break;
7631
7632 case 900: hash_type = HASH_TYPE_MD4;
7633 salt_type = SALT_TYPE_NONE;
7634 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7635 opts_type = OPTS_TYPE_PT_GENERATE_LE
7636 | OPTS_TYPE_PT_ADD80
7637 | OPTS_TYPE_PT_ADDBITS14;
7638 kern_type = KERN_TYPE_MD4;
7639 dgst_size = DGST_SIZE_4_4;
7640 parse_func = md4_parse_hash;
7641 sort_by_digest = sort_by_digest_4_4;
7642 opti_type = OPTI_TYPE_ZERO_BYTE
7643 | OPTI_TYPE_PRECOMPUTE_INIT
7644 | OPTI_TYPE_PRECOMPUTE_MERKLE
7645 | OPTI_TYPE_MEET_IN_MIDDLE
7646 | OPTI_TYPE_EARLY_SKIP
7647 | OPTI_TYPE_NOT_ITERATED
7648 | OPTI_TYPE_NOT_SALTED
7649 | OPTI_TYPE_RAW_HASH;
7650 dgst_pos0 = 0;
7651 dgst_pos1 = 3;
7652 dgst_pos2 = 2;
7653 dgst_pos3 = 1;
7654 break;
7655
7656 case 1000: hash_type = HASH_TYPE_MD4;
7657 salt_type = SALT_TYPE_NONE;
7658 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7659 opts_type = OPTS_TYPE_PT_GENERATE_LE
7660 | OPTS_TYPE_PT_ADD80
7661 | OPTS_TYPE_PT_ADDBITS14
7662 | OPTS_TYPE_PT_UNICODE;
7663 kern_type = KERN_TYPE_MD4_PWU;
7664 dgst_size = DGST_SIZE_4_4;
7665 parse_func = md4_parse_hash;
7666 sort_by_digest = sort_by_digest_4_4;
7667 opti_type = OPTI_TYPE_ZERO_BYTE
7668 | OPTI_TYPE_PRECOMPUTE_INIT
7669 | OPTI_TYPE_PRECOMPUTE_MERKLE
7670 | OPTI_TYPE_MEET_IN_MIDDLE
7671 | OPTI_TYPE_EARLY_SKIP
7672 | OPTI_TYPE_NOT_ITERATED
7673 | OPTI_TYPE_NOT_SALTED
7674 | OPTI_TYPE_RAW_HASH;
7675 dgst_pos0 = 0;
7676 dgst_pos1 = 3;
7677 dgst_pos2 = 2;
7678 dgst_pos3 = 1;
7679 break;
7680
7681 case 1100: hash_type = HASH_TYPE_MD4;
7682 salt_type = SALT_TYPE_INTERN;
7683 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7684 opts_type = OPTS_TYPE_PT_GENERATE_LE
7685 | OPTS_TYPE_PT_ADD80
7686 | OPTS_TYPE_PT_ADDBITS14
7687 | OPTS_TYPE_PT_UNICODE
7688 | OPTS_TYPE_ST_ADD80
7689 | OPTS_TYPE_ST_UNICODE
7690 | OPTS_TYPE_ST_LOWER;
7691 kern_type = KERN_TYPE_MD44_PWUSLT;
7692 dgst_size = DGST_SIZE_4_4;
7693 parse_func = dcc_parse_hash;
7694 sort_by_digest = sort_by_digest_4_4;
7695 opti_type = OPTI_TYPE_ZERO_BYTE
7696 | OPTI_TYPE_PRECOMPUTE_INIT
7697 | OPTI_TYPE_PRECOMPUTE_MERKLE
7698 | OPTI_TYPE_EARLY_SKIP
7699 | OPTI_TYPE_NOT_ITERATED;
7700 dgst_pos0 = 0;
7701 dgst_pos1 = 3;
7702 dgst_pos2 = 2;
7703 dgst_pos3 = 1;
7704 break;
7705
7706 case 1400: hash_type = HASH_TYPE_SHA256;
7707 salt_type = SALT_TYPE_NONE;
7708 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7709 opts_type = OPTS_TYPE_PT_GENERATE_BE
7710 | OPTS_TYPE_PT_ADD80
7711 | OPTS_TYPE_PT_ADDBITS15;
7712 kern_type = KERN_TYPE_SHA256;
7713 dgst_size = DGST_SIZE_4_8;
7714 parse_func = sha256_parse_hash;
7715 sort_by_digest = sort_by_digest_4_8;
7716 opti_type = OPTI_TYPE_ZERO_BYTE
7717 | OPTI_TYPE_PRECOMPUTE_INIT
7718 | OPTI_TYPE_PRECOMPUTE_MERKLE
7719 | OPTI_TYPE_EARLY_SKIP
7720 | OPTI_TYPE_NOT_ITERATED
7721 | OPTI_TYPE_NOT_SALTED
7722 | OPTI_TYPE_RAW_HASH;
7723 dgst_pos0 = 3;
7724 dgst_pos1 = 7;
7725 dgst_pos2 = 2;
7726 dgst_pos3 = 6;
7727 break;
7728
7729 case 1410: hash_type = HASH_TYPE_SHA256;
7730 salt_type = SALT_TYPE_INTERN;
7731 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7732 opts_type = OPTS_TYPE_PT_GENERATE_BE
7733 | OPTS_TYPE_ST_ADD80
7734 | OPTS_TYPE_ST_ADDBITS15;
7735 kern_type = KERN_TYPE_SHA256_PWSLT;
7736 dgst_size = DGST_SIZE_4_8;
7737 parse_func = sha256s_parse_hash;
7738 sort_by_digest = sort_by_digest_4_8;
7739 opti_type = OPTI_TYPE_ZERO_BYTE
7740 | OPTI_TYPE_PRECOMPUTE_INIT
7741 | OPTI_TYPE_PRECOMPUTE_MERKLE
7742 | OPTI_TYPE_EARLY_SKIP
7743 | OPTI_TYPE_NOT_ITERATED
7744 | OPTI_TYPE_APPENDED_SALT
7745 | OPTI_TYPE_RAW_HASH;
7746 dgst_pos0 = 3;
7747 dgst_pos1 = 7;
7748 dgst_pos2 = 2;
7749 dgst_pos3 = 6;
7750 break;
7751
7752 case 1420: hash_type = HASH_TYPE_SHA256;
7753 salt_type = SALT_TYPE_INTERN;
7754 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7755 opts_type = OPTS_TYPE_PT_GENERATE_BE
7756 | OPTS_TYPE_PT_ADD80
7757 | OPTS_TYPE_PT_ADDBITS15;
7758 kern_type = KERN_TYPE_SHA256_SLTPW;
7759 dgst_size = DGST_SIZE_4_8;
7760 parse_func = sha256s_parse_hash;
7761 sort_by_digest = sort_by_digest_4_8;
7762 opti_type = OPTI_TYPE_ZERO_BYTE
7763 | OPTI_TYPE_PRECOMPUTE_INIT
7764 | OPTI_TYPE_PRECOMPUTE_MERKLE
7765 | OPTI_TYPE_EARLY_SKIP
7766 | OPTI_TYPE_NOT_ITERATED
7767 | OPTI_TYPE_PREPENDED_SALT
7768 | OPTI_TYPE_RAW_HASH;
7769 dgst_pos0 = 3;
7770 dgst_pos1 = 7;
7771 dgst_pos2 = 2;
7772 dgst_pos3 = 6;
7773 break;
7774
7775 case 1421: hash_type = HASH_TYPE_SHA256;
7776 salt_type = SALT_TYPE_EMBEDDED;
7777 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7778 opts_type = OPTS_TYPE_PT_GENERATE_BE
7779 | OPTS_TYPE_PT_ADD80
7780 | OPTS_TYPE_PT_ADDBITS15;
7781 kern_type = KERN_TYPE_SHA256_SLTPW;
7782 dgst_size = DGST_SIZE_4_8;
7783 parse_func = hmailserver_parse_hash;
7784 sort_by_digest = sort_by_digest_4_8;
7785 opti_type = OPTI_TYPE_ZERO_BYTE
7786 | OPTI_TYPE_PRECOMPUTE_INIT
7787 | OPTI_TYPE_PRECOMPUTE_MERKLE
7788 | OPTI_TYPE_EARLY_SKIP
7789 | OPTI_TYPE_NOT_ITERATED
7790 | OPTI_TYPE_PREPENDED_SALT
7791 | OPTI_TYPE_RAW_HASH;
7792 dgst_pos0 = 3;
7793 dgst_pos1 = 7;
7794 dgst_pos2 = 2;
7795 dgst_pos3 = 6;
7796 break;
7797
7798 case 1430: hash_type = HASH_TYPE_SHA256;
7799 salt_type = SALT_TYPE_INTERN;
7800 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7801 opts_type = OPTS_TYPE_PT_GENERATE_BE
7802 | OPTS_TYPE_PT_UNICODE
7803 | OPTS_TYPE_ST_ADD80
7804 | OPTS_TYPE_ST_ADDBITS15;
7805 kern_type = KERN_TYPE_SHA256_PWUSLT;
7806 dgst_size = DGST_SIZE_4_8;
7807 parse_func = sha256s_parse_hash;
7808 sort_by_digest = sort_by_digest_4_8;
7809 opti_type = OPTI_TYPE_ZERO_BYTE
7810 | OPTI_TYPE_PRECOMPUTE_INIT
7811 | OPTI_TYPE_PRECOMPUTE_MERKLE
7812 | OPTI_TYPE_EARLY_SKIP
7813 | OPTI_TYPE_NOT_ITERATED
7814 | OPTI_TYPE_APPENDED_SALT
7815 | OPTI_TYPE_RAW_HASH;
7816 dgst_pos0 = 3;
7817 dgst_pos1 = 7;
7818 dgst_pos2 = 2;
7819 dgst_pos3 = 6;
7820 break;
7821
7822 case 1440: hash_type = HASH_TYPE_SHA256;
7823 salt_type = SALT_TYPE_INTERN;
7824 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7825 opts_type = OPTS_TYPE_PT_GENERATE_BE
7826 | OPTS_TYPE_PT_ADD80
7827 | OPTS_TYPE_PT_ADDBITS15
7828 | OPTS_TYPE_PT_UNICODE;
7829 kern_type = KERN_TYPE_SHA256_SLTPWU;
7830 dgst_size = DGST_SIZE_4_8;
7831 parse_func = sha256s_parse_hash;
7832 sort_by_digest = sort_by_digest_4_8;
7833 opti_type = OPTI_TYPE_ZERO_BYTE
7834 | OPTI_TYPE_PRECOMPUTE_INIT
7835 | OPTI_TYPE_PRECOMPUTE_MERKLE
7836 | OPTI_TYPE_EARLY_SKIP
7837 | OPTI_TYPE_NOT_ITERATED
7838 | OPTI_TYPE_PREPENDED_SALT
7839 | OPTI_TYPE_RAW_HASH;
7840 dgst_pos0 = 3;
7841 dgst_pos1 = 7;
7842 dgst_pos2 = 2;
7843 dgst_pos3 = 6;
7844 break;
7845
7846 case 1441: hash_type = HASH_TYPE_SHA256;
7847 salt_type = SALT_TYPE_EMBEDDED;
7848 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7849 opts_type = OPTS_TYPE_PT_GENERATE_BE
7850 | OPTS_TYPE_PT_ADD80
7851 | OPTS_TYPE_PT_ADDBITS15
7852 | OPTS_TYPE_PT_UNICODE
7853 | OPTS_TYPE_ST_BASE64;
7854 kern_type = KERN_TYPE_SHA256_SLTPWU;
7855 dgst_size = DGST_SIZE_4_8;
7856 parse_func = episerver4_parse_hash;
7857 sort_by_digest = sort_by_digest_4_8;
7858 opti_type = OPTI_TYPE_ZERO_BYTE
7859 | OPTI_TYPE_PRECOMPUTE_INIT
7860 | OPTI_TYPE_PRECOMPUTE_MERKLE
7861 | OPTI_TYPE_EARLY_SKIP
7862 | OPTI_TYPE_NOT_ITERATED
7863 | OPTI_TYPE_PREPENDED_SALT
7864 | OPTI_TYPE_RAW_HASH;
7865 dgst_pos0 = 3;
7866 dgst_pos1 = 7;
7867 dgst_pos2 = 2;
7868 dgst_pos3 = 6;
7869 break;
7870
7871 case 1450: hash_type = HASH_TYPE_SHA256;
7872 salt_type = SALT_TYPE_INTERN;
7873 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7874 opts_type = OPTS_TYPE_PT_GENERATE_BE
7875 | OPTS_TYPE_ST_ADD80;
7876 kern_type = KERN_TYPE_HMACSHA256_PW;
7877 dgst_size = DGST_SIZE_4_8;
7878 parse_func = hmacsha256_parse_hash;
7879 sort_by_digest = sort_by_digest_4_8;
7880 opti_type = OPTI_TYPE_ZERO_BYTE
7881 | OPTI_TYPE_NOT_ITERATED;
7882 dgst_pos0 = 3;
7883 dgst_pos1 = 7;
7884 dgst_pos2 = 2;
7885 dgst_pos3 = 6;
7886 break;
7887
7888 case 1460: hash_type = HASH_TYPE_SHA256;
7889 salt_type = SALT_TYPE_INTERN;
7890 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7891 opts_type = OPTS_TYPE_PT_GENERATE_BE
7892 | OPTS_TYPE_PT_ADD80
7893 | OPTS_TYPE_PT_ADDBITS15;
7894 kern_type = KERN_TYPE_HMACSHA256_SLT;
7895 dgst_size = DGST_SIZE_4_8;
7896 parse_func = hmacsha256_parse_hash;
7897 sort_by_digest = sort_by_digest_4_8;
7898 opti_type = OPTI_TYPE_ZERO_BYTE
7899 | OPTI_TYPE_NOT_ITERATED;
7900 dgst_pos0 = 3;
7901 dgst_pos1 = 7;
7902 dgst_pos2 = 2;
7903 dgst_pos3 = 6;
7904 break;
7905
7906 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7907 salt_type = SALT_TYPE_EMBEDDED;
7908 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7909 opts_type = OPTS_TYPE_PT_GENERATE_LE
7910 | OPTS_TYPE_PT_BITSLICE;
7911 kern_type = KERN_TYPE_DESCRYPT;
7912 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7913 parse_func = descrypt_parse_hash;
7914 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7915 opti_type = OPTI_TYPE_ZERO_BYTE
7916 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7917 dgst_pos0 = 0;
7918 dgst_pos1 = 1;
7919 dgst_pos2 = 2;
7920 dgst_pos3 = 3;
7921 break;
7922
7923 case 1600: hash_type = HASH_TYPE_MD5;
7924 salt_type = SALT_TYPE_EMBEDDED;
7925 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7926 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7927 kern_type = KERN_TYPE_APR1CRYPT;
7928 dgst_size = DGST_SIZE_4_4;
7929 parse_func = md5apr1_parse_hash;
7930 sort_by_digest = sort_by_digest_4_4;
7931 opti_type = OPTI_TYPE_ZERO_BYTE;
7932 dgst_pos0 = 0;
7933 dgst_pos1 = 1;
7934 dgst_pos2 = 2;
7935 dgst_pos3 = 3;
7936 break;
7937
7938 case 1700: hash_type = HASH_TYPE_SHA512;
7939 salt_type = SALT_TYPE_NONE;
7940 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7941 opts_type = OPTS_TYPE_PT_GENERATE_BE
7942 | OPTS_TYPE_PT_ADD80
7943 | OPTS_TYPE_PT_ADDBITS15;
7944 kern_type = KERN_TYPE_SHA512;
7945 dgst_size = DGST_SIZE_8_8;
7946 parse_func = sha512_parse_hash;
7947 sort_by_digest = sort_by_digest_8_8;
7948 opti_type = OPTI_TYPE_ZERO_BYTE
7949 | OPTI_TYPE_PRECOMPUTE_INIT
7950 | OPTI_TYPE_PRECOMPUTE_MERKLE
7951 | OPTI_TYPE_EARLY_SKIP
7952 | OPTI_TYPE_NOT_ITERATED
7953 | OPTI_TYPE_NOT_SALTED
7954 | OPTI_TYPE_USES_BITS_64
7955 | OPTI_TYPE_RAW_HASH;
7956 dgst_pos0 = 14;
7957 dgst_pos1 = 15;
7958 dgst_pos2 = 6;
7959 dgst_pos3 = 7;
7960 break;
7961
7962 case 1710: hash_type = HASH_TYPE_SHA512;
7963 salt_type = SALT_TYPE_INTERN;
7964 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7965 opts_type = OPTS_TYPE_PT_GENERATE_BE
7966 | OPTS_TYPE_ST_ADD80
7967 | OPTS_TYPE_ST_ADDBITS15;
7968 kern_type = KERN_TYPE_SHA512_PWSLT;
7969 dgst_size = DGST_SIZE_8_8;
7970 parse_func = sha512s_parse_hash;
7971 sort_by_digest = sort_by_digest_8_8;
7972 opti_type = OPTI_TYPE_ZERO_BYTE
7973 | OPTI_TYPE_PRECOMPUTE_INIT
7974 | OPTI_TYPE_PRECOMPUTE_MERKLE
7975 | OPTI_TYPE_EARLY_SKIP
7976 | OPTI_TYPE_NOT_ITERATED
7977 | OPTI_TYPE_APPENDED_SALT
7978 | OPTI_TYPE_USES_BITS_64
7979 | OPTI_TYPE_RAW_HASH;
7980 dgst_pos0 = 14;
7981 dgst_pos1 = 15;
7982 dgst_pos2 = 6;
7983 dgst_pos3 = 7;
7984 break;
7985
7986 case 1711: hash_type = HASH_TYPE_SHA512;
7987 salt_type = SALT_TYPE_EMBEDDED;
7988 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7989 opts_type = OPTS_TYPE_PT_GENERATE_BE
7990 | OPTS_TYPE_ST_ADD80
7991 | OPTS_TYPE_ST_ADDBITS15;
7992 kern_type = KERN_TYPE_SHA512_PWSLT;
7993 dgst_size = DGST_SIZE_8_8;
7994 parse_func = sha512b64s_parse_hash;
7995 sort_by_digest = sort_by_digest_8_8;
7996 opti_type = OPTI_TYPE_ZERO_BYTE
7997 | OPTI_TYPE_PRECOMPUTE_INIT
7998 | OPTI_TYPE_PRECOMPUTE_MERKLE
7999 | OPTI_TYPE_EARLY_SKIP
8000 | OPTI_TYPE_NOT_ITERATED
8001 | OPTI_TYPE_APPENDED_SALT
8002 | OPTI_TYPE_USES_BITS_64
8003 | OPTI_TYPE_RAW_HASH;
8004 dgst_pos0 = 14;
8005 dgst_pos1 = 15;
8006 dgst_pos2 = 6;
8007 dgst_pos3 = 7;
8008 break;
8009
8010 case 1720: hash_type = HASH_TYPE_SHA512;
8011 salt_type = SALT_TYPE_INTERN;
8012 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8013 opts_type = OPTS_TYPE_PT_GENERATE_BE
8014 | OPTS_TYPE_PT_ADD80
8015 | OPTS_TYPE_PT_ADDBITS15;
8016 kern_type = KERN_TYPE_SHA512_SLTPW;
8017 dgst_size = DGST_SIZE_8_8;
8018 parse_func = sha512s_parse_hash;
8019 sort_by_digest = sort_by_digest_8_8;
8020 opti_type = OPTI_TYPE_ZERO_BYTE
8021 | OPTI_TYPE_PRECOMPUTE_INIT
8022 | OPTI_TYPE_PRECOMPUTE_MERKLE
8023 | OPTI_TYPE_EARLY_SKIP
8024 | OPTI_TYPE_NOT_ITERATED
8025 | OPTI_TYPE_PREPENDED_SALT
8026 | OPTI_TYPE_USES_BITS_64
8027 | OPTI_TYPE_RAW_HASH;
8028 dgst_pos0 = 14;
8029 dgst_pos1 = 15;
8030 dgst_pos2 = 6;
8031 dgst_pos3 = 7;
8032 break;
8033
8034 case 1722: hash_type = HASH_TYPE_SHA512;
8035 salt_type = SALT_TYPE_EMBEDDED;
8036 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8037 opts_type = OPTS_TYPE_PT_GENERATE_BE
8038 | OPTS_TYPE_PT_ADD80
8039 | OPTS_TYPE_PT_ADDBITS15
8040 | OPTS_TYPE_ST_HEX;
8041 kern_type = KERN_TYPE_SHA512_SLTPW;
8042 dgst_size = DGST_SIZE_8_8;
8043 parse_func = osx512_parse_hash;
8044 sort_by_digest = sort_by_digest_8_8;
8045 opti_type = OPTI_TYPE_ZERO_BYTE
8046 | OPTI_TYPE_PRECOMPUTE_INIT
8047 | OPTI_TYPE_PRECOMPUTE_MERKLE
8048 | OPTI_TYPE_EARLY_SKIP
8049 | OPTI_TYPE_NOT_ITERATED
8050 | OPTI_TYPE_PREPENDED_SALT
8051 | OPTI_TYPE_USES_BITS_64
8052 | OPTI_TYPE_RAW_HASH;
8053 dgst_pos0 = 14;
8054 dgst_pos1 = 15;
8055 dgst_pos2 = 6;
8056 dgst_pos3 = 7;
8057 break;
8058
8059 case 1730: hash_type = HASH_TYPE_SHA512;
8060 salt_type = SALT_TYPE_INTERN;
8061 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8062 opts_type = OPTS_TYPE_PT_GENERATE_BE
8063 | OPTS_TYPE_PT_UNICODE
8064 | OPTS_TYPE_ST_ADD80
8065 | OPTS_TYPE_ST_ADDBITS15;
8066 kern_type = KERN_TYPE_SHA512_PWSLTU;
8067 dgst_size = DGST_SIZE_8_8;
8068 parse_func = sha512s_parse_hash;
8069 sort_by_digest = sort_by_digest_8_8;
8070 opti_type = OPTI_TYPE_ZERO_BYTE
8071 | OPTI_TYPE_PRECOMPUTE_INIT
8072 | OPTI_TYPE_PRECOMPUTE_MERKLE
8073 | OPTI_TYPE_EARLY_SKIP
8074 | OPTI_TYPE_NOT_ITERATED
8075 | OPTI_TYPE_APPENDED_SALT
8076 | OPTI_TYPE_USES_BITS_64
8077 | OPTI_TYPE_RAW_HASH;
8078 dgst_pos0 = 14;
8079 dgst_pos1 = 15;
8080 dgst_pos2 = 6;
8081 dgst_pos3 = 7;
8082 break;
8083
8084 case 1731: hash_type = HASH_TYPE_SHA512;
8085 salt_type = SALT_TYPE_EMBEDDED;
8086 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8087 opts_type = OPTS_TYPE_PT_GENERATE_BE
8088 | OPTS_TYPE_PT_UNICODE
8089 | OPTS_TYPE_ST_ADD80
8090 | OPTS_TYPE_ST_ADDBITS15
8091 | OPTS_TYPE_ST_HEX;
8092 kern_type = KERN_TYPE_SHA512_PWSLTU;
8093 dgst_size = DGST_SIZE_8_8;
8094 parse_func = mssql2012_parse_hash;
8095 sort_by_digest = sort_by_digest_8_8;
8096 opti_type = OPTI_TYPE_ZERO_BYTE
8097 | OPTI_TYPE_PRECOMPUTE_INIT
8098 | OPTI_TYPE_PRECOMPUTE_MERKLE
8099 | OPTI_TYPE_EARLY_SKIP
8100 | OPTI_TYPE_NOT_ITERATED
8101 | OPTI_TYPE_APPENDED_SALT
8102 | OPTI_TYPE_USES_BITS_64
8103 | OPTI_TYPE_RAW_HASH;
8104 dgst_pos0 = 14;
8105 dgst_pos1 = 15;
8106 dgst_pos2 = 6;
8107 dgst_pos3 = 7;
8108 break;
8109
8110 case 1740: hash_type = HASH_TYPE_SHA512;
8111 salt_type = SALT_TYPE_INTERN;
8112 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8113 opts_type = OPTS_TYPE_PT_GENERATE_BE
8114 | OPTS_TYPE_PT_ADD80
8115 | OPTS_TYPE_PT_ADDBITS15
8116 | OPTS_TYPE_PT_UNICODE;
8117 kern_type = KERN_TYPE_SHA512_SLTPWU;
8118 dgst_size = DGST_SIZE_8_8;
8119 parse_func = sha512s_parse_hash;
8120 sort_by_digest = sort_by_digest_8_8;
8121 opti_type = OPTI_TYPE_ZERO_BYTE
8122 | OPTI_TYPE_PRECOMPUTE_INIT
8123 | OPTI_TYPE_PRECOMPUTE_MERKLE
8124 | OPTI_TYPE_EARLY_SKIP
8125 | OPTI_TYPE_NOT_ITERATED
8126 | OPTI_TYPE_PREPENDED_SALT
8127 | OPTI_TYPE_USES_BITS_64
8128 | OPTI_TYPE_RAW_HASH;
8129 dgst_pos0 = 14;
8130 dgst_pos1 = 15;
8131 dgst_pos2 = 6;
8132 dgst_pos3 = 7;
8133 break;
8134
8135 case 1750: hash_type = HASH_TYPE_SHA512;
8136 salt_type = SALT_TYPE_INTERN;
8137 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8138 opts_type = OPTS_TYPE_PT_GENERATE_BE
8139 | OPTS_TYPE_ST_ADD80;
8140 kern_type = KERN_TYPE_HMACSHA512_PW;
8141 dgst_size = DGST_SIZE_8_8;
8142 parse_func = hmacsha512_parse_hash;
8143 sort_by_digest = sort_by_digest_8_8;
8144 opti_type = OPTI_TYPE_ZERO_BYTE
8145 | OPTI_TYPE_USES_BITS_64
8146 | OPTI_TYPE_NOT_ITERATED;
8147 dgst_pos0 = 14;
8148 dgst_pos1 = 15;
8149 dgst_pos2 = 6;
8150 dgst_pos3 = 7;
8151 break;
8152
8153 case 1760: hash_type = HASH_TYPE_SHA512;
8154 salt_type = SALT_TYPE_INTERN;
8155 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8156 opts_type = OPTS_TYPE_PT_GENERATE_BE
8157 | OPTS_TYPE_PT_ADD80
8158 | OPTS_TYPE_PT_ADDBITS15;
8159 kern_type = KERN_TYPE_HMACSHA512_SLT;
8160 dgst_size = DGST_SIZE_8_8;
8161 parse_func = hmacsha512_parse_hash;
8162 sort_by_digest = sort_by_digest_8_8;
8163 opti_type = OPTI_TYPE_ZERO_BYTE
8164 | OPTI_TYPE_USES_BITS_64
8165 | OPTI_TYPE_NOT_ITERATED;
8166 dgst_pos0 = 14;
8167 dgst_pos1 = 15;
8168 dgst_pos2 = 6;
8169 dgst_pos3 = 7;
8170 break;
8171
8172 case 1800: hash_type = HASH_TYPE_SHA512;
8173 salt_type = SALT_TYPE_EMBEDDED;
8174 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8175 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8176 kern_type = KERN_TYPE_SHA512CRYPT;
8177 dgst_size = DGST_SIZE_8_8;
8178 parse_func = sha512crypt_parse_hash;
8179 sort_by_digest = sort_by_digest_8_8;
8180 opti_type = OPTI_TYPE_ZERO_BYTE
8181 | OPTI_TYPE_USES_BITS_64;
8182 dgst_pos0 = 0;
8183 dgst_pos1 = 1;
8184 dgst_pos2 = 2;
8185 dgst_pos3 = 3;
8186 break;
8187
8188 case 2100: hash_type = HASH_TYPE_DCC2;
8189 salt_type = SALT_TYPE_EMBEDDED;
8190 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8191 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8192 | OPTS_TYPE_ST_LOWER
8193 | OPTS_TYPE_ST_UNICODE;
8194 kern_type = KERN_TYPE_DCC2;
8195 dgst_size = DGST_SIZE_4_4;
8196 parse_func = dcc2_parse_hash;
8197 sort_by_digest = sort_by_digest_4_4;
8198 opti_type = OPTI_TYPE_ZERO_BYTE;
8199 dgst_pos0 = 0;
8200 dgst_pos1 = 1;
8201 dgst_pos2 = 2;
8202 dgst_pos3 = 3;
8203 break;
8204
8205 case 2400: hash_type = HASH_TYPE_MD5;
8206 salt_type = SALT_TYPE_NONE;
8207 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8208 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8209 kern_type = KERN_TYPE_MD5PIX;
8210 dgst_size = DGST_SIZE_4_4;
8211 parse_func = md5pix_parse_hash;
8212 sort_by_digest = sort_by_digest_4_4;
8213 opti_type = OPTI_TYPE_ZERO_BYTE
8214 | OPTI_TYPE_PRECOMPUTE_INIT
8215 | OPTI_TYPE_PRECOMPUTE_MERKLE
8216 | OPTI_TYPE_EARLY_SKIP
8217 | OPTI_TYPE_NOT_ITERATED
8218 | OPTI_TYPE_NOT_SALTED;
8219 dgst_pos0 = 0;
8220 dgst_pos1 = 3;
8221 dgst_pos2 = 2;
8222 dgst_pos3 = 1;
8223 break;
8224
8225 case 2410: hash_type = HASH_TYPE_MD5;
8226 salt_type = SALT_TYPE_INTERN;
8227 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8228 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8229 kern_type = KERN_TYPE_MD5ASA;
8230 dgst_size = DGST_SIZE_4_4;
8231 parse_func = md5asa_parse_hash;
8232 sort_by_digest = sort_by_digest_4_4;
8233 opti_type = OPTI_TYPE_ZERO_BYTE
8234 | OPTI_TYPE_PRECOMPUTE_INIT
8235 | OPTI_TYPE_PRECOMPUTE_MERKLE
8236 | OPTI_TYPE_EARLY_SKIP
8237 | OPTI_TYPE_NOT_ITERATED;
8238 dgst_pos0 = 0;
8239 dgst_pos1 = 3;
8240 dgst_pos2 = 2;
8241 dgst_pos3 = 1;
8242 break;
8243
8244 case 2500: hash_type = HASH_TYPE_WPA;
8245 salt_type = SALT_TYPE_EMBEDDED;
8246 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8247 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8248 kern_type = KERN_TYPE_WPA;
8249 dgst_size = DGST_SIZE_4_4;
8250 parse_func = wpa_parse_hash;
8251 sort_by_digest = sort_by_digest_4_4;
8252 opti_type = OPTI_TYPE_ZERO_BYTE;
8253 dgst_pos0 = 0;
8254 dgst_pos1 = 1;
8255 dgst_pos2 = 2;
8256 dgst_pos3 = 3;
8257 break;
8258
8259 case 2600: hash_type = HASH_TYPE_MD5;
8260 salt_type = SALT_TYPE_VIRTUAL;
8261 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8262 opts_type = OPTS_TYPE_PT_GENERATE_LE
8263 | OPTS_TYPE_PT_ADD80
8264 | OPTS_TYPE_PT_ADDBITS14
8265 | OPTS_TYPE_ST_ADD80;
8266 kern_type = KERN_TYPE_MD55_PWSLT1;
8267 dgst_size = DGST_SIZE_4_4;
8268 parse_func = md5md5_parse_hash;
8269 sort_by_digest = sort_by_digest_4_4;
8270 opti_type = OPTI_TYPE_ZERO_BYTE
8271 | OPTI_TYPE_PRECOMPUTE_INIT
8272 | OPTI_TYPE_PRECOMPUTE_MERKLE
8273 | OPTI_TYPE_EARLY_SKIP;
8274 dgst_pos0 = 0;
8275 dgst_pos1 = 3;
8276 dgst_pos2 = 2;
8277 dgst_pos3 = 1;
8278 break;
8279
8280 case 2611: hash_type = HASH_TYPE_MD5;
8281 salt_type = SALT_TYPE_INTERN;
8282 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8283 opts_type = OPTS_TYPE_PT_GENERATE_LE
8284 | OPTS_TYPE_PT_ADD80
8285 | OPTS_TYPE_PT_ADDBITS14
8286 | OPTS_TYPE_ST_ADD80;
8287 kern_type = KERN_TYPE_MD55_PWSLT1;
8288 dgst_size = DGST_SIZE_4_4;
8289 parse_func = vb3_parse_hash;
8290 sort_by_digest = sort_by_digest_4_4;
8291 opti_type = OPTI_TYPE_ZERO_BYTE
8292 | OPTI_TYPE_PRECOMPUTE_INIT
8293 | OPTI_TYPE_PRECOMPUTE_MERKLE
8294 | OPTI_TYPE_EARLY_SKIP;
8295 dgst_pos0 = 0;
8296 dgst_pos1 = 3;
8297 dgst_pos2 = 2;
8298 dgst_pos3 = 1;
8299 break;
8300
8301 case 2612: hash_type = HASH_TYPE_MD5;
8302 salt_type = SALT_TYPE_EMBEDDED;
8303 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8304 opts_type = OPTS_TYPE_PT_GENERATE_LE
8305 | OPTS_TYPE_PT_ADD80
8306 | OPTS_TYPE_PT_ADDBITS14
8307 | OPTS_TYPE_ST_ADD80
8308 | OPTS_TYPE_ST_HEX;
8309 kern_type = KERN_TYPE_MD55_PWSLT1;
8310 dgst_size = DGST_SIZE_4_4;
8311 parse_func = phps_parse_hash;
8312 sort_by_digest = sort_by_digest_4_4;
8313 opti_type = OPTI_TYPE_ZERO_BYTE
8314 | OPTI_TYPE_PRECOMPUTE_INIT
8315 | OPTI_TYPE_PRECOMPUTE_MERKLE
8316 | OPTI_TYPE_EARLY_SKIP;
8317 dgst_pos0 = 0;
8318 dgst_pos1 = 3;
8319 dgst_pos2 = 2;
8320 dgst_pos3 = 1;
8321 break;
8322
8323 case 2711: hash_type = HASH_TYPE_MD5;
8324 salt_type = SALT_TYPE_INTERN;
8325 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8326 opts_type = OPTS_TYPE_PT_GENERATE_LE
8327 | OPTS_TYPE_PT_ADD80
8328 | OPTS_TYPE_PT_ADDBITS14
8329 | OPTS_TYPE_ST_ADD80;
8330 kern_type = KERN_TYPE_MD55_PWSLT2;
8331 dgst_size = DGST_SIZE_4_4;
8332 parse_func = vb30_parse_hash;
8333 sort_by_digest = sort_by_digest_4_4;
8334 opti_type = OPTI_TYPE_ZERO_BYTE
8335 | OPTI_TYPE_PRECOMPUTE_INIT
8336 | OPTI_TYPE_EARLY_SKIP;
8337 dgst_pos0 = 0;
8338 dgst_pos1 = 3;
8339 dgst_pos2 = 2;
8340 dgst_pos3 = 1;
8341 break;
8342
8343 case 2811: hash_type = HASH_TYPE_MD5;
8344 salt_type = SALT_TYPE_INTERN;
8345 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8346 opts_type = OPTS_TYPE_PT_GENERATE_LE
8347 | OPTS_TYPE_PT_ADD80
8348 | OPTS_TYPE_PT_ADDBITS14;
8349 kern_type = KERN_TYPE_MD55_SLTPW;
8350 dgst_size = DGST_SIZE_4_4;
8351 parse_func = ipb2_parse_hash;
8352 sort_by_digest = sort_by_digest_4_4;
8353 opti_type = OPTI_TYPE_ZERO_BYTE
8354 | OPTI_TYPE_PRECOMPUTE_INIT
8355 | OPTI_TYPE_EARLY_SKIP;
8356 dgst_pos0 = 0;
8357 dgst_pos1 = 3;
8358 dgst_pos2 = 2;
8359 dgst_pos3 = 1;
8360 break;
8361
8362 case 3000: hash_type = HASH_TYPE_LM;
8363 salt_type = SALT_TYPE_NONE;
8364 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8365 opts_type = OPTS_TYPE_PT_GENERATE_LE
8366 | OPTS_TYPE_PT_UPPER
8367 | OPTS_TYPE_PT_BITSLICE;
8368 kern_type = KERN_TYPE_LM;
8369 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8370 parse_func = lm_parse_hash;
8371 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8372 opti_type = OPTI_TYPE_ZERO_BYTE
8373 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8374 dgst_pos0 = 0;
8375 dgst_pos1 = 1;
8376 dgst_pos2 = 2;
8377 dgst_pos3 = 3;
8378 break;
8379
8380 case 3100: hash_type = HASH_TYPE_ORACLEH;
8381 salt_type = SALT_TYPE_INTERN;
8382 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8383 opts_type = OPTS_TYPE_PT_GENERATE_LE
8384 | OPTS_TYPE_PT_UPPER
8385 | OPTS_TYPE_ST_UPPER;
8386 kern_type = KERN_TYPE_ORACLEH;
8387 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8388 parse_func = oracleh_parse_hash;
8389 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8390 opti_type = OPTI_TYPE_ZERO_BYTE;
8391 dgst_pos0 = 0;
8392 dgst_pos1 = 1;
8393 dgst_pos2 = 2;
8394 dgst_pos3 = 3;
8395 break;
8396
8397 case 3200: hash_type = HASH_TYPE_BCRYPT;
8398 salt_type = SALT_TYPE_EMBEDDED;
8399 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8400 opts_type = OPTS_TYPE_PT_GENERATE_LE
8401 | OPTS_TYPE_ST_GENERATE_LE;
8402 kern_type = KERN_TYPE_BCRYPT;
8403 dgst_size = DGST_SIZE_4_6;
8404 parse_func = bcrypt_parse_hash;
8405 sort_by_digest = sort_by_digest_4_6;
8406 opti_type = OPTI_TYPE_ZERO_BYTE;
8407 dgst_pos0 = 0;
8408 dgst_pos1 = 1;
8409 dgst_pos2 = 2;
8410 dgst_pos3 = 3;
8411 break;
8412
8413 case 3710: hash_type = HASH_TYPE_MD5;
8414 salt_type = SALT_TYPE_INTERN;
8415 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8416 opts_type = OPTS_TYPE_PT_GENERATE_LE
8417 | OPTS_TYPE_PT_ADD80
8418 | OPTS_TYPE_PT_ADDBITS14;
8419 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8420 dgst_size = DGST_SIZE_4_4;
8421 parse_func = md5s_parse_hash;
8422 sort_by_digest = sort_by_digest_4_4;
8423 opti_type = OPTI_TYPE_ZERO_BYTE
8424 | OPTI_TYPE_PRECOMPUTE_INIT
8425 | OPTI_TYPE_PRECOMPUTE_MERKLE
8426 | OPTI_TYPE_EARLY_SKIP;
8427 dgst_pos0 = 0;
8428 dgst_pos1 = 3;
8429 dgst_pos2 = 2;
8430 dgst_pos3 = 1;
8431 break;
8432
8433 case 3711: hash_type = HASH_TYPE_MD5;
8434 salt_type = SALT_TYPE_EMBEDDED;
8435 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8436 opts_type = OPTS_TYPE_PT_GENERATE_LE
8437 | OPTS_TYPE_PT_ADD80
8438 | OPTS_TYPE_PT_ADDBITS14;
8439 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8440 dgst_size = DGST_SIZE_4_4;
8441 parse_func = mediawiki_b_parse_hash;
8442 sort_by_digest = sort_by_digest_4_4;
8443 opti_type = OPTI_TYPE_ZERO_BYTE
8444 | OPTI_TYPE_PRECOMPUTE_INIT
8445 | OPTI_TYPE_PRECOMPUTE_MERKLE
8446 | OPTI_TYPE_EARLY_SKIP;
8447 dgst_pos0 = 0;
8448 dgst_pos1 = 3;
8449 dgst_pos2 = 2;
8450 dgst_pos3 = 1;
8451 break;
8452
8453 case 3800: hash_type = HASH_TYPE_MD5;
8454 salt_type = SALT_TYPE_INTERN;
8455 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8456 opts_type = OPTS_TYPE_PT_GENERATE_LE
8457 | OPTS_TYPE_ST_ADDBITS14;
8458 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8459 dgst_size = DGST_SIZE_4_4;
8460 parse_func = md5s_parse_hash;
8461 sort_by_digest = sort_by_digest_4_4;
8462 opti_type = OPTI_TYPE_ZERO_BYTE
8463 | OPTI_TYPE_PRECOMPUTE_INIT
8464 | OPTI_TYPE_PRECOMPUTE_MERKLE
8465 | OPTI_TYPE_EARLY_SKIP
8466 | OPTI_TYPE_NOT_ITERATED
8467 | OPTI_TYPE_RAW_HASH;
8468 dgst_pos0 = 0;
8469 dgst_pos1 = 3;
8470 dgst_pos2 = 2;
8471 dgst_pos3 = 1;
8472 break;
8473
8474 case 4300: hash_type = HASH_TYPE_MD5;
8475 salt_type = SALT_TYPE_VIRTUAL;
8476 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8477 opts_type = OPTS_TYPE_PT_GENERATE_LE
8478 | OPTS_TYPE_PT_ADD80
8479 | OPTS_TYPE_PT_ADDBITS14
8480 | OPTS_TYPE_ST_ADD80;
8481 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8482 dgst_size = DGST_SIZE_4_4;
8483 parse_func = md5md5_parse_hash;
8484 sort_by_digest = sort_by_digest_4_4;
8485 opti_type = OPTI_TYPE_ZERO_BYTE
8486 | OPTI_TYPE_PRECOMPUTE_INIT
8487 | OPTI_TYPE_PRECOMPUTE_MERKLE
8488 | OPTI_TYPE_EARLY_SKIP;
8489 dgst_pos0 = 0;
8490 dgst_pos1 = 3;
8491 dgst_pos2 = 2;
8492 dgst_pos3 = 1;
8493 break;
8494
8495
8496 case 4400: hash_type = HASH_TYPE_MD5;
8497 salt_type = SALT_TYPE_NONE;
8498 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8499 opts_type = OPTS_TYPE_PT_GENERATE_BE
8500 | OPTS_TYPE_PT_ADD80
8501 | OPTS_TYPE_PT_ADDBITS15;
8502 kern_type = KERN_TYPE_MD5_SHA1;
8503 dgst_size = DGST_SIZE_4_4;
8504 parse_func = md5_parse_hash;
8505 sort_by_digest = sort_by_digest_4_4;
8506 opti_type = OPTI_TYPE_ZERO_BYTE
8507 | OPTI_TYPE_PRECOMPUTE_INIT
8508 | OPTI_TYPE_PRECOMPUTE_MERKLE
8509 | OPTI_TYPE_EARLY_SKIP
8510 | OPTI_TYPE_NOT_ITERATED
8511 | OPTI_TYPE_NOT_SALTED
8512 | OPTI_TYPE_RAW_HASH;
8513 dgst_pos0 = 0;
8514 dgst_pos1 = 3;
8515 dgst_pos2 = 2;
8516 dgst_pos3 = 1;
8517 break;
8518
8519 case 4500: hash_type = HASH_TYPE_SHA1;
8520 salt_type = SALT_TYPE_NONE;
8521 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8522 opts_type = OPTS_TYPE_PT_GENERATE_BE
8523 | OPTS_TYPE_PT_ADD80
8524 | OPTS_TYPE_PT_ADDBITS15;
8525 kern_type = KERN_TYPE_SHA11;
8526 dgst_size = DGST_SIZE_4_5;
8527 parse_func = sha1_parse_hash;
8528 sort_by_digest = sort_by_digest_4_5;
8529 opti_type = OPTI_TYPE_ZERO_BYTE
8530 | OPTI_TYPE_PRECOMPUTE_INIT
8531 | OPTI_TYPE_PRECOMPUTE_MERKLE
8532 | OPTI_TYPE_EARLY_SKIP
8533 | OPTI_TYPE_NOT_SALTED;
8534 dgst_pos0 = 3;
8535 dgst_pos1 = 4;
8536 dgst_pos2 = 2;
8537 dgst_pos3 = 1;
8538 break;
8539
8540 case 4700: hash_type = HASH_TYPE_SHA1;
8541 salt_type = SALT_TYPE_NONE;
8542 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8543 opts_type = OPTS_TYPE_PT_GENERATE_LE
8544 | OPTS_TYPE_PT_ADD80
8545 | OPTS_TYPE_PT_ADDBITS14;
8546 kern_type = KERN_TYPE_SHA1_MD5;
8547 dgst_size = DGST_SIZE_4_5;
8548 parse_func = sha1_parse_hash;
8549 sort_by_digest = sort_by_digest_4_5;
8550 opti_type = OPTI_TYPE_ZERO_BYTE
8551 | OPTI_TYPE_PRECOMPUTE_INIT
8552 | OPTI_TYPE_PRECOMPUTE_MERKLE
8553 | OPTI_TYPE_EARLY_SKIP
8554 | OPTI_TYPE_NOT_ITERATED
8555 | OPTI_TYPE_NOT_SALTED
8556 | OPTI_TYPE_RAW_HASH;
8557 dgst_pos0 = 3;
8558 dgst_pos1 = 4;
8559 dgst_pos2 = 2;
8560 dgst_pos3 = 1;
8561 break;
8562
8563 case 4800: hash_type = HASH_TYPE_MD5;
8564 salt_type = SALT_TYPE_EMBEDDED;
8565 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8566 opts_type = OPTS_TYPE_PT_GENERATE_LE
8567 | OPTS_TYPE_PT_ADDBITS14;
8568 kern_type = KERN_TYPE_MD5_CHAP;
8569 dgst_size = DGST_SIZE_4_4;
8570 parse_func = chap_parse_hash;
8571 sort_by_digest = sort_by_digest_4_4;
8572 opti_type = OPTI_TYPE_ZERO_BYTE
8573 | OPTI_TYPE_PRECOMPUTE_INIT
8574 | OPTI_TYPE_PRECOMPUTE_MERKLE
8575 | OPTI_TYPE_MEET_IN_MIDDLE
8576 | OPTI_TYPE_EARLY_SKIP
8577 | OPTI_TYPE_NOT_ITERATED
8578 | OPTI_TYPE_RAW_HASH;
8579 dgst_pos0 = 0;
8580 dgst_pos1 = 3;
8581 dgst_pos2 = 2;
8582 dgst_pos3 = 1;
8583 break;
8584
8585 case 4900: hash_type = HASH_TYPE_SHA1;
8586 salt_type = SALT_TYPE_INTERN;
8587 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8588 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8589 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8590 dgst_size = DGST_SIZE_4_5;
8591 parse_func = sha1s_parse_hash;
8592 sort_by_digest = sort_by_digest_4_5;
8593 opti_type = OPTI_TYPE_ZERO_BYTE
8594 | OPTI_TYPE_PRECOMPUTE_INIT
8595 | OPTI_TYPE_PRECOMPUTE_MERKLE
8596 | OPTI_TYPE_EARLY_SKIP;
8597 dgst_pos0 = 3;
8598 dgst_pos1 = 4;
8599 dgst_pos2 = 2;
8600 dgst_pos3 = 1;
8601 break;
8602
8603 case 5000: hash_type = HASH_TYPE_KECCAK;
8604 salt_type = SALT_TYPE_EMBEDDED;
8605 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8606 opts_type = OPTS_TYPE_PT_GENERATE_LE
8607 | OPTS_TYPE_PT_ADD01;
8608 kern_type = KERN_TYPE_KECCAK;
8609 dgst_size = DGST_SIZE_8_25;
8610 parse_func = keccak_parse_hash;
8611 sort_by_digest = sort_by_digest_8_25;
8612 opti_type = OPTI_TYPE_ZERO_BYTE
8613 | OPTI_TYPE_USES_BITS_64
8614 | OPTI_TYPE_RAW_HASH;
8615 dgst_pos0 = 2;
8616 dgst_pos1 = 3;
8617 dgst_pos2 = 4;
8618 dgst_pos3 = 5;
8619 break;
8620
8621 case 5100: hash_type = HASH_TYPE_MD5H;
8622 salt_type = SALT_TYPE_NONE;
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 kern_type = KERN_TYPE_MD5H;
8628 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8629 parse_func = md5half_parse_hash;
8630 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8631 opti_type = OPTI_TYPE_ZERO_BYTE
8632 | OPTI_TYPE_RAW_HASH;
8633 dgst_pos0 = 0;
8634 dgst_pos1 = 1;
8635 dgst_pos2 = 2;
8636 dgst_pos3 = 3;
8637 break;
8638
8639 case 5200: hash_type = HASH_TYPE_SHA256;
8640 salt_type = SALT_TYPE_EMBEDDED;
8641 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8642 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8643 kern_type = KERN_TYPE_PSAFE3;
8644 dgst_size = DGST_SIZE_4_8;
8645 parse_func = psafe3_parse_hash;
8646 sort_by_digest = sort_by_digest_4_8;
8647 opti_type = OPTI_TYPE_ZERO_BYTE;
8648 dgst_pos0 = 0;
8649 dgst_pos1 = 1;
8650 dgst_pos2 = 2;
8651 dgst_pos3 = 3;
8652 break;
8653
8654 case 5300: hash_type = HASH_TYPE_MD5;
8655 salt_type = SALT_TYPE_EMBEDDED;
8656 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8657 opts_type = OPTS_TYPE_PT_GENERATE_LE
8658 | OPTS_TYPE_ST_ADD80;
8659 kern_type = KERN_TYPE_IKEPSK_MD5;
8660 dgst_size = DGST_SIZE_4_4;
8661 parse_func = ikepsk_md5_parse_hash;
8662 sort_by_digest = sort_by_digest_4_4;
8663 opti_type = OPTI_TYPE_ZERO_BYTE;
8664 dgst_pos0 = 0;
8665 dgst_pos1 = 3;
8666 dgst_pos2 = 2;
8667 dgst_pos3 = 1;
8668 break;
8669
8670 case 5400: hash_type = HASH_TYPE_SHA1;
8671 salt_type = SALT_TYPE_EMBEDDED;
8672 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8673 opts_type = OPTS_TYPE_PT_GENERATE_BE
8674 | OPTS_TYPE_ST_ADD80;
8675 kern_type = KERN_TYPE_IKEPSK_SHA1;
8676 dgst_size = DGST_SIZE_4_5;
8677 parse_func = ikepsk_sha1_parse_hash;
8678 sort_by_digest = sort_by_digest_4_5;
8679 opti_type = OPTI_TYPE_ZERO_BYTE;
8680 dgst_pos0 = 3;
8681 dgst_pos1 = 4;
8682 dgst_pos2 = 2;
8683 dgst_pos3 = 1;
8684 break;
8685
8686 case 5500: hash_type = HASH_TYPE_NETNTLM;
8687 salt_type = SALT_TYPE_EMBEDDED;
8688 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8689 opts_type = OPTS_TYPE_PT_GENERATE_LE
8690 | OPTS_TYPE_PT_ADD80
8691 | OPTS_TYPE_PT_ADDBITS14
8692 | OPTS_TYPE_PT_UNICODE
8693 | OPTS_TYPE_ST_HEX;
8694 kern_type = KERN_TYPE_NETNTLMv1;
8695 dgst_size = DGST_SIZE_4_4;
8696 parse_func = netntlmv1_parse_hash;
8697 sort_by_digest = sort_by_digest_4_4;
8698 opti_type = OPTI_TYPE_ZERO_BYTE
8699 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8700 dgst_pos0 = 0;
8701 dgst_pos1 = 1;
8702 dgst_pos2 = 2;
8703 dgst_pos3 = 3;
8704 break;
8705
8706 case 5600: hash_type = HASH_TYPE_MD5;
8707 salt_type = SALT_TYPE_EMBEDDED;
8708 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8709 opts_type = OPTS_TYPE_PT_GENERATE_LE
8710 | OPTS_TYPE_PT_ADD80
8711 | OPTS_TYPE_PT_ADDBITS14
8712 | OPTS_TYPE_PT_UNICODE;
8713 kern_type = KERN_TYPE_NETNTLMv2;
8714 dgst_size = DGST_SIZE_4_4;
8715 parse_func = netntlmv2_parse_hash;
8716 sort_by_digest = sort_by_digest_4_4;
8717 opti_type = OPTI_TYPE_ZERO_BYTE;
8718 dgst_pos0 = 0;
8719 dgst_pos1 = 3;
8720 dgst_pos2 = 2;
8721 dgst_pos3 = 1;
8722 break;
8723
8724 case 5700: hash_type = HASH_TYPE_SHA256;
8725 salt_type = SALT_TYPE_NONE;
8726 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8727 opts_type = OPTS_TYPE_PT_GENERATE_BE
8728 | OPTS_TYPE_PT_ADD80
8729 | OPTS_TYPE_PT_ADDBITS15;
8730 kern_type = KERN_TYPE_SHA256;
8731 dgst_size = DGST_SIZE_4_8;
8732 parse_func = cisco4_parse_hash;
8733 sort_by_digest = sort_by_digest_4_8;
8734 opti_type = OPTI_TYPE_ZERO_BYTE
8735 | OPTI_TYPE_PRECOMPUTE_INIT
8736 | OPTI_TYPE_PRECOMPUTE_MERKLE
8737 | OPTI_TYPE_EARLY_SKIP
8738 | OPTI_TYPE_NOT_ITERATED
8739 | OPTI_TYPE_NOT_SALTED
8740 | OPTI_TYPE_RAW_HASH;
8741 dgst_pos0 = 3;
8742 dgst_pos1 = 7;
8743 dgst_pos2 = 2;
8744 dgst_pos3 = 6;
8745 break;
8746
8747 case 5800: hash_type = HASH_TYPE_SHA1;
8748 salt_type = SALT_TYPE_INTERN;
8749 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8750 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8751 | OPTS_TYPE_ST_ADD80;
8752 kern_type = KERN_TYPE_ANDROIDPIN;
8753 dgst_size = DGST_SIZE_4_5;
8754 parse_func = androidpin_parse_hash;
8755 sort_by_digest = sort_by_digest_4_5;
8756 opti_type = OPTI_TYPE_ZERO_BYTE;
8757 dgst_pos0 = 0;
8758 dgst_pos1 = 1;
8759 dgst_pos2 = 2;
8760 dgst_pos3 = 3;
8761 break;
8762
8763 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8764 salt_type = SALT_TYPE_NONE;
8765 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8766 opts_type = OPTS_TYPE_PT_GENERATE_LE
8767 | OPTS_TYPE_PT_ADD80;
8768 kern_type = KERN_TYPE_RIPEMD160;
8769 dgst_size = DGST_SIZE_4_5;
8770 parse_func = ripemd160_parse_hash;
8771 sort_by_digest = sort_by_digest_4_5;
8772 opti_type = OPTI_TYPE_ZERO_BYTE;
8773 dgst_pos0 = 0;
8774 dgst_pos1 = 1;
8775 dgst_pos2 = 2;
8776 dgst_pos3 = 3;
8777 break;
8778
8779 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8780 salt_type = SALT_TYPE_NONE;
8781 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8782 opts_type = OPTS_TYPE_PT_GENERATE_BE
8783 | OPTS_TYPE_PT_ADD80;
8784 kern_type = KERN_TYPE_WHIRLPOOL;
8785 dgst_size = DGST_SIZE_4_16;
8786 parse_func = whirlpool_parse_hash;
8787 sort_by_digest = sort_by_digest_4_16;
8788 opti_type = OPTI_TYPE_ZERO_BYTE;
8789 dgst_pos0 = 0;
8790 dgst_pos1 = 1;
8791 dgst_pos2 = 2;
8792 dgst_pos3 = 3;
8793 break;
8794
8795 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8796 salt_type = SALT_TYPE_EMBEDDED;
8797 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8798 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8799 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8800 dgst_size = DGST_SIZE_4_5;
8801 parse_func = truecrypt_parse_hash_2k;
8802 sort_by_digest = sort_by_digest_4_5;
8803 opti_type = OPTI_TYPE_ZERO_BYTE;
8804 dgst_pos0 = 0;
8805 dgst_pos1 = 1;
8806 dgst_pos2 = 2;
8807 dgst_pos3 = 3;
8808 break;
8809
8810 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8811 salt_type = SALT_TYPE_EMBEDDED;
8812 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8813 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8814 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8815 dgst_size = DGST_SIZE_4_5;
8816 parse_func = truecrypt_parse_hash_2k;
8817 sort_by_digest = sort_by_digest_4_5;
8818 opti_type = OPTI_TYPE_ZERO_BYTE;
8819 dgst_pos0 = 0;
8820 dgst_pos1 = 1;
8821 dgst_pos2 = 2;
8822 dgst_pos3 = 3;
8823 break;
8824
8825 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8826 salt_type = SALT_TYPE_EMBEDDED;
8827 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8828 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8829 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8830 dgst_size = DGST_SIZE_4_5;
8831 parse_func = truecrypt_parse_hash_2k;
8832 sort_by_digest = sort_by_digest_4_5;
8833 opti_type = OPTI_TYPE_ZERO_BYTE;
8834 dgst_pos0 = 0;
8835 dgst_pos1 = 1;
8836 dgst_pos2 = 2;
8837 dgst_pos3 = 3;
8838 break;
8839
8840 case 6221: hash_type = HASH_TYPE_SHA512;
8841 salt_type = SALT_TYPE_EMBEDDED;
8842 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8843 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8844 kern_type = KERN_TYPE_TCSHA512_XTS512;
8845 dgst_size = DGST_SIZE_8_8;
8846 parse_func = truecrypt_parse_hash_1k;
8847 sort_by_digest = sort_by_digest_8_8;
8848 opti_type = OPTI_TYPE_ZERO_BYTE
8849 | OPTI_TYPE_USES_BITS_64;
8850 dgst_pos0 = 0;
8851 dgst_pos1 = 1;
8852 dgst_pos2 = 2;
8853 dgst_pos3 = 3;
8854 break;
8855
8856 case 6222: hash_type = HASH_TYPE_SHA512;
8857 salt_type = SALT_TYPE_EMBEDDED;
8858 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8859 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8860 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8861 dgst_size = DGST_SIZE_8_8;
8862 parse_func = truecrypt_parse_hash_1k;
8863 sort_by_digest = sort_by_digest_8_8;
8864 opti_type = OPTI_TYPE_ZERO_BYTE
8865 | OPTI_TYPE_USES_BITS_64;
8866 dgst_pos0 = 0;
8867 dgst_pos1 = 1;
8868 dgst_pos2 = 2;
8869 dgst_pos3 = 3;
8870 break;
8871
8872 case 6223: hash_type = HASH_TYPE_SHA512;
8873 salt_type = SALT_TYPE_EMBEDDED;
8874 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8875 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8876 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8877 dgst_size = DGST_SIZE_8_8;
8878 parse_func = truecrypt_parse_hash_1k;
8879 sort_by_digest = sort_by_digest_8_8;
8880 opti_type = OPTI_TYPE_ZERO_BYTE
8881 | OPTI_TYPE_USES_BITS_64;
8882 dgst_pos0 = 0;
8883 dgst_pos1 = 1;
8884 dgst_pos2 = 2;
8885 dgst_pos3 = 3;
8886 break;
8887
8888 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8889 salt_type = SALT_TYPE_EMBEDDED;
8890 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8891 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8892 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8893 dgst_size = DGST_SIZE_4_8;
8894 parse_func = truecrypt_parse_hash_1k;
8895 sort_by_digest = sort_by_digest_4_8;
8896 opti_type = OPTI_TYPE_ZERO_BYTE;
8897 dgst_pos0 = 0;
8898 dgst_pos1 = 1;
8899 dgst_pos2 = 2;
8900 dgst_pos3 = 3;
8901 break;
8902
8903 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8904 salt_type = SALT_TYPE_EMBEDDED;
8905 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8906 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8907 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8908 dgst_size = DGST_SIZE_4_8;
8909 parse_func = truecrypt_parse_hash_1k;
8910 sort_by_digest = sort_by_digest_4_8;
8911 opti_type = OPTI_TYPE_ZERO_BYTE;
8912 dgst_pos0 = 0;
8913 dgst_pos1 = 1;
8914 dgst_pos2 = 2;
8915 dgst_pos3 = 3;
8916 break;
8917
8918 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8919 salt_type = SALT_TYPE_EMBEDDED;
8920 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8921 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8922 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8923 dgst_size = DGST_SIZE_4_8;
8924 parse_func = truecrypt_parse_hash_1k;
8925 sort_by_digest = sort_by_digest_4_8;
8926 opti_type = OPTI_TYPE_ZERO_BYTE;
8927 dgst_pos0 = 0;
8928 dgst_pos1 = 1;
8929 dgst_pos2 = 2;
8930 dgst_pos3 = 3;
8931 break;
8932
8933 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8934 salt_type = SALT_TYPE_EMBEDDED;
8935 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8936 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8937 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8938 dgst_size = DGST_SIZE_4_5;
8939 parse_func = truecrypt_parse_hash_1k;
8940 sort_by_digest = sort_by_digest_4_5;
8941 opti_type = OPTI_TYPE_ZERO_BYTE;
8942 dgst_pos0 = 0;
8943 dgst_pos1 = 1;
8944 dgst_pos2 = 2;
8945 dgst_pos3 = 3;
8946 break;
8947
8948 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8949 salt_type = SALT_TYPE_EMBEDDED;
8950 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8951 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8952 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8953 dgst_size = DGST_SIZE_4_5;
8954 parse_func = truecrypt_parse_hash_1k;
8955 sort_by_digest = sort_by_digest_4_5;
8956 opti_type = OPTI_TYPE_ZERO_BYTE;
8957 dgst_pos0 = 0;
8958 dgst_pos1 = 1;
8959 dgst_pos2 = 2;
8960 dgst_pos3 = 3;
8961 break;
8962
8963 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8964 salt_type = SALT_TYPE_EMBEDDED;
8965 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8966 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8967 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8968 dgst_size = DGST_SIZE_4_5;
8969 parse_func = truecrypt_parse_hash_1k;
8970 sort_by_digest = sort_by_digest_4_5;
8971 opti_type = OPTI_TYPE_ZERO_BYTE;
8972 dgst_pos0 = 0;
8973 dgst_pos1 = 1;
8974 dgst_pos2 = 2;
8975 dgst_pos3 = 3;
8976 break;
8977
8978 case 6300: hash_type = HASH_TYPE_MD5;
8979 salt_type = SALT_TYPE_EMBEDDED;
8980 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8981 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8982 kern_type = KERN_TYPE_MD5AIX;
8983 dgst_size = DGST_SIZE_4_4;
8984 parse_func = md5aix_parse_hash;
8985 sort_by_digest = sort_by_digest_4_4;
8986 opti_type = OPTI_TYPE_ZERO_BYTE;
8987 dgst_pos0 = 0;
8988 dgst_pos1 = 1;
8989 dgst_pos2 = 2;
8990 dgst_pos3 = 3;
8991 break;
8992
8993 case 6400: hash_type = HASH_TYPE_SHA256;
8994 salt_type = SALT_TYPE_EMBEDDED;
8995 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8996 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8997 kern_type = KERN_TYPE_SHA256AIX;
8998 dgst_size = DGST_SIZE_4_8;
8999 parse_func = sha256aix_parse_hash;
9000 sort_by_digest = sort_by_digest_4_8;
9001 opti_type = OPTI_TYPE_ZERO_BYTE;
9002 dgst_pos0 = 0;
9003 dgst_pos1 = 1;
9004 dgst_pos2 = 2;
9005 dgst_pos3 = 3;
9006 break;
9007
9008 case 6500: hash_type = HASH_TYPE_SHA512;
9009 salt_type = SALT_TYPE_EMBEDDED;
9010 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9011 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9012 kern_type = KERN_TYPE_SHA512AIX;
9013 dgst_size = DGST_SIZE_8_8;
9014 parse_func = sha512aix_parse_hash;
9015 sort_by_digest = sort_by_digest_8_8;
9016 opti_type = OPTI_TYPE_ZERO_BYTE
9017 | OPTI_TYPE_USES_BITS_64;
9018 dgst_pos0 = 0;
9019 dgst_pos1 = 1;
9020 dgst_pos2 = 2;
9021 dgst_pos3 = 3;
9022 break;
9023
9024 case 6600: hash_type = HASH_TYPE_AES;
9025 salt_type = SALT_TYPE_EMBEDDED;
9026 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9027 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9028 kern_type = KERN_TYPE_AGILEKEY;
9029 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9030 parse_func = agilekey_parse_hash;
9031 sort_by_digest = sort_by_digest_4_5;
9032 opti_type = OPTI_TYPE_ZERO_BYTE;
9033 dgst_pos0 = 0;
9034 dgst_pos1 = 1;
9035 dgst_pos2 = 2;
9036 dgst_pos3 = 3;
9037 break;
9038
9039 case 6700: hash_type = HASH_TYPE_SHA1;
9040 salt_type = SALT_TYPE_EMBEDDED;
9041 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9042 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9043 kern_type = KERN_TYPE_SHA1AIX;
9044 dgst_size = DGST_SIZE_4_5;
9045 parse_func = sha1aix_parse_hash;
9046 sort_by_digest = sort_by_digest_4_5;
9047 opti_type = OPTI_TYPE_ZERO_BYTE;
9048 dgst_pos0 = 0;
9049 dgst_pos1 = 1;
9050 dgst_pos2 = 2;
9051 dgst_pos3 = 3;
9052 break;
9053
9054 case 6800: hash_type = HASH_TYPE_AES;
9055 salt_type = SALT_TYPE_EMBEDDED;
9056 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9057 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9058 kern_type = KERN_TYPE_LASTPASS;
9059 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9060 parse_func = lastpass_parse_hash;
9061 sort_by_digest = sort_by_digest_4_8;
9062 opti_type = OPTI_TYPE_ZERO_BYTE;
9063 dgst_pos0 = 0;
9064 dgst_pos1 = 1;
9065 dgst_pos2 = 2;
9066 dgst_pos3 = 3;
9067 break;
9068
9069 case 6900: hash_type = HASH_TYPE_GOST;
9070 salt_type = SALT_TYPE_NONE;
9071 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9072 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9073 kern_type = KERN_TYPE_GOST;
9074 dgst_size = DGST_SIZE_4_8;
9075 parse_func = gost_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 7100: hash_type = HASH_TYPE_SHA512;
9085 salt_type = SALT_TYPE_EMBEDDED;
9086 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9087 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9088 kern_type = KERN_TYPE_PBKDF2_SHA512;
9089 dgst_size = DGST_SIZE_8_16;
9090 parse_func = sha512osx_parse_hash;
9091 sort_by_digest = sort_by_digest_8_16;
9092 opti_type = OPTI_TYPE_ZERO_BYTE
9093 | OPTI_TYPE_USES_BITS_64;
9094 dgst_pos0 = 0;
9095 dgst_pos1 = 1;
9096 dgst_pos2 = 2;
9097 dgst_pos3 = 3;
9098 break;
9099
9100 case 7200: hash_type = HASH_TYPE_SHA512;
9101 salt_type = SALT_TYPE_EMBEDDED;
9102 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9103 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9104 kern_type = KERN_TYPE_PBKDF2_SHA512;
9105 dgst_size = DGST_SIZE_8_16;
9106 parse_func = sha512grub_parse_hash;
9107 sort_by_digest = sort_by_digest_8_16;
9108 opti_type = OPTI_TYPE_ZERO_BYTE
9109 | OPTI_TYPE_USES_BITS_64;
9110 dgst_pos0 = 0;
9111 dgst_pos1 = 1;
9112 dgst_pos2 = 2;
9113 dgst_pos3 = 3;
9114 break;
9115
9116 case 7300: hash_type = HASH_TYPE_SHA1;
9117 salt_type = SALT_TYPE_EMBEDDED;
9118 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9119 opts_type = OPTS_TYPE_PT_GENERATE_BE
9120 | OPTS_TYPE_ST_ADD80
9121 | OPTS_TYPE_ST_ADDBITS15;
9122 kern_type = KERN_TYPE_RAKP;
9123 dgst_size = DGST_SIZE_4_5;
9124 parse_func = rakp_parse_hash;
9125 sort_by_digest = sort_by_digest_4_5;
9126 opti_type = OPTI_TYPE_ZERO_BYTE
9127 | OPTI_TYPE_NOT_ITERATED;
9128 dgst_pos0 = 3;
9129 dgst_pos1 = 4;
9130 dgst_pos2 = 2;
9131 dgst_pos3 = 1;
9132 break;
9133
9134 case 7400: hash_type = HASH_TYPE_SHA256;
9135 salt_type = SALT_TYPE_EMBEDDED;
9136 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9137 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9138 kern_type = KERN_TYPE_SHA256CRYPT;
9139 dgst_size = DGST_SIZE_4_8;
9140 parse_func = sha256crypt_parse_hash;
9141 sort_by_digest = sort_by_digest_4_8;
9142 opti_type = OPTI_TYPE_ZERO_BYTE;
9143 dgst_pos0 = 0;
9144 dgst_pos1 = 1;
9145 dgst_pos2 = 2;
9146 dgst_pos3 = 3;
9147 break;
9148
9149 case 7500: hash_type = HASH_TYPE_KRB5PA;
9150 salt_type = SALT_TYPE_EMBEDDED;
9151 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9152 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9153 kern_type = KERN_TYPE_KRB5PA;
9154 dgst_size = DGST_SIZE_4_4;
9155 parse_func = krb5pa_parse_hash;
9156 sort_by_digest = sort_by_digest_4_4;
9157 opti_type = OPTI_TYPE_ZERO_BYTE
9158 | OPTI_TYPE_NOT_ITERATED;
9159 dgst_pos0 = 0;
9160 dgst_pos1 = 1;
9161 dgst_pos2 = 2;
9162 dgst_pos3 = 3;
9163 break;
9164
9165 case 7600: hash_type = HASH_TYPE_SHA1;
9166 salt_type = SALT_TYPE_INTERN;
9167 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9168 opts_type = OPTS_TYPE_PT_GENERATE_BE
9169 | OPTS_TYPE_PT_ADD80
9170 | OPTS_TYPE_PT_ADDBITS15;
9171 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9172 dgst_size = DGST_SIZE_4_5;
9173 parse_func = redmine_parse_hash;
9174 sort_by_digest = sort_by_digest_4_5;
9175 opti_type = OPTI_TYPE_ZERO_BYTE
9176 | OPTI_TYPE_PRECOMPUTE_INIT
9177 | OPTI_TYPE_EARLY_SKIP
9178 | OPTI_TYPE_NOT_ITERATED
9179 | OPTI_TYPE_PREPENDED_SALT;
9180 dgst_pos0 = 3;
9181 dgst_pos1 = 4;
9182 dgst_pos2 = 2;
9183 dgst_pos3 = 1;
9184 break;
9185
9186 case 7700: hash_type = HASH_TYPE_SAPB;
9187 salt_type = SALT_TYPE_EMBEDDED;
9188 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9189 opts_type = OPTS_TYPE_PT_GENERATE_LE
9190 | OPTS_TYPE_PT_UPPER
9191 | OPTS_TYPE_ST_UPPER;
9192 kern_type = KERN_TYPE_SAPB;
9193 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9194 parse_func = sapb_parse_hash;
9195 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9196 opti_type = OPTI_TYPE_ZERO_BYTE
9197 | OPTI_TYPE_PRECOMPUTE_INIT
9198 | OPTI_TYPE_NOT_ITERATED;
9199 dgst_pos0 = 0;
9200 dgst_pos1 = 1;
9201 dgst_pos2 = 2;
9202 dgst_pos3 = 3;
9203 break;
9204
9205 case 7800: hash_type = HASH_TYPE_SAPG;
9206 salt_type = SALT_TYPE_EMBEDDED;
9207 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9208 opts_type = OPTS_TYPE_PT_GENERATE_BE
9209 | OPTS_TYPE_ST_ADD80
9210 | OPTS_TYPE_ST_UPPER;
9211 kern_type = KERN_TYPE_SAPG;
9212 dgst_size = DGST_SIZE_4_5;
9213 parse_func = sapg_parse_hash;
9214 sort_by_digest = sort_by_digest_4_5;
9215 opti_type = OPTI_TYPE_ZERO_BYTE
9216 | OPTI_TYPE_PRECOMPUTE_INIT
9217 | OPTI_TYPE_NOT_ITERATED;
9218 dgst_pos0 = 3;
9219 dgst_pos1 = 4;
9220 dgst_pos2 = 2;
9221 dgst_pos3 = 1;
9222 break;
9223
9224 case 7900: hash_type = HASH_TYPE_SHA512;
9225 salt_type = SALT_TYPE_EMBEDDED;
9226 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9227 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9228 kern_type = KERN_TYPE_DRUPAL7;
9229 dgst_size = DGST_SIZE_8_8;
9230 parse_func = drupal7_parse_hash;
9231 sort_by_digest = sort_by_digest_8_8;
9232 opti_type = OPTI_TYPE_ZERO_BYTE
9233 | OPTI_TYPE_USES_BITS_64;
9234 dgst_pos0 = 0;
9235 dgst_pos1 = 1;
9236 dgst_pos2 = 2;
9237 dgst_pos3 = 3;
9238 break;
9239
9240 case 8000: hash_type = HASH_TYPE_SHA256;
9241 salt_type = SALT_TYPE_EMBEDDED;
9242 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9243 opts_type = OPTS_TYPE_PT_GENERATE_BE
9244 | OPTS_TYPE_PT_UNICODE
9245 | OPTS_TYPE_ST_ADD80
9246 | OPTS_TYPE_ST_HEX;
9247 kern_type = KERN_TYPE_SYBASEASE;
9248 dgst_size = DGST_SIZE_4_8;
9249 parse_func = sybasease_parse_hash;
9250 sort_by_digest = sort_by_digest_4_8;
9251 opti_type = OPTI_TYPE_ZERO_BYTE
9252 | OPTI_TYPE_PRECOMPUTE_INIT
9253 | OPTI_TYPE_EARLY_SKIP
9254 | OPTI_TYPE_NOT_ITERATED
9255 | OPTI_TYPE_RAW_HASH;
9256 dgst_pos0 = 3;
9257 dgst_pos1 = 7;
9258 dgst_pos2 = 2;
9259 dgst_pos3 = 6;
9260 break;
9261
9262 case 8100: hash_type = HASH_TYPE_SHA1;
9263 salt_type = SALT_TYPE_EMBEDDED;
9264 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9265 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9266 kern_type = KERN_TYPE_NETSCALER;
9267 dgst_size = DGST_SIZE_4_5;
9268 parse_func = netscaler_parse_hash;
9269 sort_by_digest = sort_by_digest_4_5;
9270 opti_type = OPTI_TYPE_ZERO_BYTE
9271 | OPTI_TYPE_PRECOMPUTE_INIT
9272 | OPTI_TYPE_PRECOMPUTE_MERKLE
9273 | OPTI_TYPE_EARLY_SKIP
9274 | OPTI_TYPE_NOT_ITERATED
9275 | OPTI_TYPE_PREPENDED_SALT
9276 | OPTI_TYPE_RAW_HASH;
9277 dgst_pos0 = 3;
9278 dgst_pos1 = 4;
9279 dgst_pos2 = 2;
9280 dgst_pos3 = 1;
9281 break;
9282
9283 case 8200: hash_type = HASH_TYPE_SHA256;
9284 salt_type = SALT_TYPE_EMBEDDED;
9285 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9286 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9287 kern_type = KERN_TYPE_CLOUDKEY;
9288 dgst_size = DGST_SIZE_4_8;
9289 parse_func = cloudkey_parse_hash;
9290 sort_by_digest = sort_by_digest_4_8;
9291 opti_type = OPTI_TYPE_ZERO_BYTE;
9292 dgst_pos0 = 0;
9293 dgst_pos1 = 1;
9294 dgst_pos2 = 2;
9295 dgst_pos3 = 3;
9296 break;
9297
9298 case 8300: hash_type = HASH_TYPE_SHA1;
9299 salt_type = SALT_TYPE_EMBEDDED;
9300 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9301 opts_type = OPTS_TYPE_PT_GENERATE_LE
9302 | OPTS_TYPE_ST_HEX
9303 | OPTS_TYPE_ST_ADD80;
9304 kern_type = KERN_TYPE_NSEC3;
9305 dgst_size = DGST_SIZE_4_5;
9306 parse_func = nsec3_parse_hash;
9307 sort_by_digest = sort_by_digest_4_5;
9308 opti_type = OPTI_TYPE_ZERO_BYTE;
9309 dgst_pos0 = 3;
9310 dgst_pos1 = 4;
9311 dgst_pos2 = 2;
9312 dgst_pos3 = 1;
9313 break;
9314
9315 case 8400: hash_type = HASH_TYPE_SHA1;
9316 salt_type = SALT_TYPE_INTERN;
9317 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9318 opts_type = OPTS_TYPE_PT_GENERATE_BE
9319 | OPTS_TYPE_PT_ADD80
9320 | OPTS_TYPE_PT_ADDBITS15;
9321 kern_type = KERN_TYPE_WBB3;
9322 dgst_size = DGST_SIZE_4_5;
9323 parse_func = wbb3_parse_hash;
9324 sort_by_digest = sort_by_digest_4_5;
9325 opti_type = OPTI_TYPE_ZERO_BYTE
9326 | OPTI_TYPE_PRECOMPUTE_INIT
9327 | OPTI_TYPE_NOT_ITERATED;
9328 dgst_pos0 = 3;
9329 dgst_pos1 = 4;
9330 dgst_pos2 = 2;
9331 dgst_pos3 = 1;
9332 break;
9333
9334 case 8500: hash_type = HASH_TYPE_DESRACF;
9335 salt_type = SALT_TYPE_EMBEDDED;
9336 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9337 opts_type = OPTS_TYPE_PT_GENERATE_LE
9338 | OPTS_TYPE_ST_UPPER;
9339 kern_type = KERN_TYPE_RACF;
9340 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9341 parse_func = racf_parse_hash;
9342 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9343 opti_type = OPTI_TYPE_ZERO_BYTE
9344 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9345 dgst_pos0 = 0;
9346 dgst_pos1 = 1;
9347 dgst_pos2 = 2;
9348 dgst_pos3 = 3;
9349 break;
9350
9351 case 8600: hash_type = HASH_TYPE_LOTUS5;
9352 salt_type = SALT_TYPE_NONE;
9353 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9354 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9355 kern_type = KERN_TYPE_LOTUS5;
9356 dgst_size = DGST_SIZE_4_4;
9357 parse_func = lotus5_parse_hash;
9358 sort_by_digest = sort_by_digest_4_4;
9359 opti_type = OPTI_TYPE_EARLY_SKIP
9360 | OPTI_TYPE_NOT_ITERATED
9361 | OPTI_TYPE_NOT_SALTED
9362 | OPTI_TYPE_RAW_HASH;
9363 dgst_pos0 = 0;
9364 dgst_pos1 = 1;
9365 dgst_pos2 = 2;
9366 dgst_pos3 = 3;
9367 break;
9368
9369 case 8700: hash_type = HASH_TYPE_LOTUS6;
9370 salt_type = SALT_TYPE_EMBEDDED;
9371 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9372 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9373 kern_type = KERN_TYPE_LOTUS6;
9374 dgst_size = DGST_SIZE_4_4;
9375 parse_func = lotus6_parse_hash;
9376 sort_by_digest = sort_by_digest_4_4;
9377 opti_type = OPTI_TYPE_EARLY_SKIP
9378 | OPTI_TYPE_NOT_ITERATED
9379 | OPTI_TYPE_RAW_HASH;
9380 dgst_pos0 = 0;
9381 dgst_pos1 = 1;
9382 dgst_pos2 = 2;
9383 dgst_pos3 = 3;
9384 break;
9385
9386 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9387 salt_type = SALT_TYPE_EMBEDDED;
9388 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9389 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9390 kern_type = KERN_TYPE_ANDROIDFDE;
9391 dgst_size = DGST_SIZE_4_4;
9392 parse_func = androidfde_parse_hash;
9393 sort_by_digest = sort_by_digest_4_4;
9394 opti_type = OPTI_TYPE_ZERO_BYTE;
9395 dgst_pos0 = 0;
9396 dgst_pos1 = 1;
9397 dgst_pos2 = 2;
9398 dgst_pos3 = 3;
9399 break;
9400
9401 case 8900: hash_type = HASH_TYPE_SCRYPT;
9402 salt_type = SALT_TYPE_EMBEDDED;
9403 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9404 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9405 kern_type = KERN_TYPE_SCRYPT;
9406 dgst_size = DGST_SIZE_4_8;
9407 parse_func = scrypt_parse_hash;
9408 sort_by_digest = sort_by_digest_4_8;
9409 opti_type = OPTI_TYPE_ZERO_BYTE;
9410 dgst_pos0 = 0;
9411 dgst_pos1 = 1;
9412 dgst_pos2 = 2;
9413 dgst_pos3 = 3;
9414 break;
9415
9416 case 9000: hash_type = HASH_TYPE_SHA1;
9417 salt_type = SALT_TYPE_EMBEDDED;
9418 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9419 opts_type = OPTS_TYPE_PT_GENERATE_LE
9420 | OPTS_TYPE_ST_GENERATE_LE;
9421 kern_type = KERN_TYPE_PSAFE2;
9422 dgst_size = DGST_SIZE_4_5;
9423 parse_func = psafe2_parse_hash;
9424 sort_by_digest = sort_by_digest_4_5;
9425 opti_type = OPTI_TYPE_ZERO_BYTE;
9426 dgst_pos0 = 0;
9427 dgst_pos1 = 1;
9428 dgst_pos2 = 2;
9429 dgst_pos3 = 3;
9430 break;
9431
9432 case 9100: hash_type = HASH_TYPE_LOTUS8;
9433 salt_type = SALT_TYPE_EMBEDDED;
9434 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9435 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9436 kern_type = KERN_TYPE_LOTUS8;
9437 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9438 parse_func = lotus8_parse_hash;
9439 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9440 opti_type = OPTI_TYPE_ZERO_BYTE;
9441 dgst_pos0 = 0;
9442 dgst_pos1 = 1;
9443 dgst_pos2 = 2;
9444 dgst_pos3 = 3;
9445 break;
9446
9447 case 9200: hash_type = HASH_TYPE_SHA256;
9448 salt_type = SALT_TYPE_EMBEDDED;
9449 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9450 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9451 kern_type = KERN_TYPE_PBKDF2_SHA256;
9452 dgst_size = DGST_SIZE_4_32;
9453 parse_func = cisco8_parse_hash;
9454 sort_by_digest = sort_by_digest_4_32;
9455 opti_type = OPTI_TYPE_ZERO_BYTE;
9456 dgst_pos0 = 0;
9457 dgst_pos1 = 1;
9458 dgst_pos2 = 2;
9459 dgst_pos3 = 3;
9460 break;
9461
9462 case 9300: hash_type = HASH_TYPE_SCRYPT;
9463 salt_type = SALT_TYPE_EMBEDDED;
9464 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9465 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9466 kern_type = KERN_TYPE_SCRYPT;
9467 dgst_size = DGST_SIZE_4_8;
9468 parse_func = cisco9_parse_hash;
9469 sort_by_digest = sort_by_digest_4_8;
9470 opti_type = OPTI_TYPE_ZERO_BYTE;
9471 dgst_pos0 = 0;
9472 dgst_pos1 = 1;
9473 dgst_pos2 = 2;
9474 dgst_pos3 = 3;
9475 break;
9476
9477 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9478 salt_type = SALT_TYPE_EMBEDDED;
9479 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9480 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9481 kern_type = KERN_TYPE_OFFICE2007;
9482 dgst_size = DGST_SIZE_4_4;
9483 parse_func = office2007_parse_hash;
9484 sort_by_digest = sort_by_digest_4_4;
9485 opti_type = OPTI_TYPE_ZERO_BYTE;
9486 dgst_pos0 = 0;
9487 dgst_pos1 = 1;
9488 dgst_pos2 = 2;
9489 dgst_pos3 = 3;
9490 break;
9491
9492 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9493 salt_type = SALT_TYPE_EMBEDDED;
9494 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9495 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9496 kern_type = KERN_TYPE_OFFICE2010;
9497 dgst_size = DGST_SIZE_4_4;
9498 parse_func = office2010_parse_hash;
9499 sort_by_digest = sort_by_digest_4_4;
9500 opti_type = OPTI_TYPE_ZERO_BYTE;
9501 dgst_pos0 = 0;
9502 dgst_pos1 = 1;
9503 dgst_pos2 = 2;
9504 dgst_pos3 = 3;
9505 break;
9506
9507 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9508 salt_type = SALT_TYPE_EMBEDDED;
9509 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9510 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9511 kern_type = KERN_TYPE_OFFICE2013;
9512 dgst_size = DGST_SIZE_4_4;
9513 parse_func = office2013_parse_hash;
9514 sort_by_digest = sort_by_digest_4_4;
9515 opti_type = OPTI_TYPE_ZERO_BYTE;
9516 dgst_pos0 = 0;
9517 dgst_pos1 = 1;
9518 dgst_pos2 = 2;
9519 dgst_pos3 = 3;
9520 break;
9521
9522 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9523 salt_type = SALT_TYPE_EMBEDDED;
9524 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9525 opts_type = OPTS_TYPE_PT_GENERATE_LE
9526 | OPTS_TYPE_PT_ADD80
9527 | OPTS_TYPE_PT_UNICODE;
9528 kern_type = KERN_TYPE_OLDOFFICE01;
9529 dgst_size = DGST_SIZE_4_4;
9530 parse_func = oldoffice01_parse_hash;
9531 sort_by_digest = sort_by_digest_4_4;
9532 opti_type = OPTI_TYPE_ZERO_BYTE
9533 | OPTI_TYPE_PRECOMPUTE_INIT
9534 | OPTI_TYPE_NOT_ITERATED;
9535 dgst_pos0 = 0;
9536 dgst_pos1 = 1;
9537 dgst_pos2 = 2;
9538 dgst_pos3 = 3;
9539 break;
9540
9541 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9542 salt_type = SALT_TYPE_EMBEDDED;
9543 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9544 opts_type = OPTS_TYPE_PT_GENERATE_LE
9545 | OPTS_TYPE_PT_ADD80;
9546 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9547 dgst_size = DGST_SIZE_4_4;
9548 parse_func = oldoffice01cm1_parse_hash;
9549 sort_by_digest = sort_by_digest_4_4;
9550 opti_type = OPTI_TYPE_ZERO_BYTE
9551 | OPTI_TYPE_PRECOMPUTE_INIT
9552 | OPTI_TYPE_NOT_ITERATED;
9553 dgst_pos0 = 0;
9554 dgst_pos1 = 1;
9555 dgst_pos2 = 2;
9556 dgst_pos3 = 3;
9557 break;
9558
9559 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9560 salt_type = SALT_TYPE_EMBEDDED;
9561 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9562 opts_type = OPTS_TYPE_PT_GENERATE_LE
9563 | OPTS_TYPE_PT_ADD80
9564 | OPTS_TYPE_PT_UNICODE
9565 | OPTS_TYPE_PT_NEVERCRACK;
9566 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9567 dgst_size = DGST_SIZE_4_4;
9568 parse_func = oldoffice01cm2_parse_hash;
9569 sort_by_digest = sort_by_digest_4_4;
9570 opti_type = OPTI_TYPE_ZERO_BYTE
9571 | OPTI_TYPE_PRECOMPUTE_INIT
9572 | OPTI_TYPE_NOT_ITERATED;
9573 dgst_pos0 = 0;
9574 dgst_pos1 = 1;
9575 dgst_pos2 = 2;
9576 dgst_pos3 = 3;
9577 break;
9578
9579 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9580 salt_type = SALT_TYPE_EMBEDDED;
9581 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9582 opts_type = OPTS_TYPE_PT_GENERATE_BE
9583 | OPTS_TYPE_PT_ADD80
9584 | OPTS_TYPE_PT_UNICODE;
9585 kern_type = KERN_TYPE_OLDOFFICE34;
9586 dgst_size = DGST_SIZE_4_4;
9587 parse_func = oldoffice34_parse_hash;
9588 sort_by_digest = sort_by_digest_4_4;
9589 opti_type = OPTI_TYPE_ZERO_BYTE
9590 | OPTI_TYPE_PRECOMPUTE_INIT
9591 | OPTI_TYPE_NOT_ITERATED;
9592 dgst_pos0 = 0;
9593 dgst_pos1 = 1;
9594 dgst_pos2 = 2;
9595 dgst_pos3 = 3;
9596 break;
9597
9598 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9599 salt_type = SALT_TYPE_EMBEDDED;
9600 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9601 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9602 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9603 dgst_size = DGST_SIZE_4_4;
9604 parse_func = oldoffice34cm1_parse_hash;
9605 sort_by_digest = sort_by_digest_4_4;
9606 opti_type = OPTI_TYPE_ZERO_BYTE
9607 | OPTI_TYPE_PRECOMPUTE_INIT
9608 | OPTI_TYPE_NOT_ITERATED;
9609 dgst_pos0 = 0;
9610 dgst_pos1 = 1;
9611 dgst_pos2 = 2;
9612 dgst_pos3 = 3;
9613 break;
9614
9615 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9616 salt_type = SALT_TYPE_EMBEDDED;
9617 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9618 opts_type = OPTS_TYPE_PT_GENERATE_BE
9619 | OPTS_TYPE_PT_ADD80
9620 | OPTS_TYPE_PT_UNICODE
9621 | OPTS_TYPE_PT_NEVERCRACK;
9622 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9623 dgst_size = DGST_SIZE_4_4;
9624 parse_func = oldoffice34cm2_parse_hash;
9625 sort_by_digest = sort_by_digest_4_4;
9626 opti_type = OPTI_TYPE_ZERO_BYTE
9627 | OPTI_TYPE_PRECOMPUTE_INIT
9628 | OPTI_TYPE_NOT_ITERATED;
9629 dgst_pos0 = 0;
9630 dgst_pos1 = 1;
9631 dgst_pos2 = 2;
9632 dgst_pos3 = 3;
9633 break;
9634
9635 case 9900: hash_type = HASH_TYPE_MD5;
9636 salt_type = SALT_TYPE_NONE;
9637 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9638 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9639 kern_type = KERN_TYPE_RADMIN2;
9640 dgst_size = DGST_SIZE_4_4;
9641 parse_func = radmin2_parse_hash;
9642 sort_by_digest = sort_by_digest_4_4;
9643 opti_type = OPTI_TYPE_ZERO_BYTE
9644 | OPTI_TYPE_PRECOMPUTE_INIT
9645 | OPTI_TYPE_EARLY_SKIP
9646 | OPTI_TYPE_NOT_ITERATED
9647 | OPTI_TYPE_NOT_SALTED;
9648 dgst_pos0 = 0;
9649 dgst_pos1 = 3;
9650 dgst_pos2 = 2;
9651 dgst_pos3 = 1;
9652 break;
9653
9654 case 10000: hash_type = HASH_TYPE_SHA256;
9655 salt_type = SALT_TYPE_EMBEDDED;
9656 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9657 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9658 kern_type = KERN_TYPE_PBKDF2_SHA256;
9659 dgst_size = DGST_SIZE_4_32;
9660 parse_func = djangopbkdf2_parse_hash;
9661 sort_by_digest = sort_by_digest_4_32;
9662 opti_type = OPTI_TYPE_ZERO_BYTE;
9663 dgst_pos0 = 0;
9664 dgst_pos1 = 1;
9665 dgst_pos2 = 2;
9666 dgst_pos3 = 3;
9667 break;
9668
9669 case 10100: hash_type = HASH_TYPE_SIPHASH;
9670 salt_type = SALT_TYPE_EMBEDDED;
9671 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9672 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9673 kern_type = KERN_TYPE_SIPHASH;
9674 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9675 parse_func = siphash_parse_hash;
9676 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9677 opti_type = OPTI_TYPE_ZERO_BYTE
9678 | OPTI_TYPE_NOT_ITERATED
9679 | OPTI_TYPE_RAW_HASH;
9680 dgst_pos0 = 0;
9681 dgst_pos1 = 1;
9682 dgst_pos2 = 2;
9683 dgst_pos3 = 3;
9684 break;
9685
9686 case 10200: hash_type = HASH_TYPE_MD5;
9687 salt_type = SALT_TYPE_EMBEDDED;
9688 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9689 opts_type = OPTS_TYPE_PT_GENERATE_LE
9690 | OPTS_TYPE_ST_ADD80
9691 | OPTS_TYPE_ST_ADDBITS14;
9692 kern_type = KERN_TYPE_HMACMD5_PW;
9693 dgst_size = DGST_SIZE_4_4;
9694 parse_func = crammd5_parse_hash;
9695 sort_by_digest = sort_by_digest_4_4;
9696 opti_type = OPTI_TYPE_ZERO_BYTE
9697 | OPTI_TYPE_NOT_ITERATED;
9698 dgst_pos0 = 0;
9699 dgst_pos1 = 3;
9700 dgst_pos2 = 2;
9701 dgst_pos3 = 1;
9702 break;
9703
9704 case 10300: hash_type = HASH_TYPE_SHA1;
9705 salt_type = SALT_TYPE_EMBEDDED;
9706 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9707 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9708 kern_type = KERN_TYPE_SAPH_SHA1;
9709 dgst_size = DGST_SIZE_4_5;
9710 parse_func = saph_sha1_parse_hash;
9711 sort_by_digest = sort_by_digest_4_5;
9712 opti_type = OPTI_TYPE_ZERO_BYTE;
9713 dgst_pos0 = 0;
9714 dgst_pos1 = 1;
9715 dgst_pos2 = 2;
9716 dgst_pos3 = 3;
9717 break;
9718
9719 case 10400: hash_type = HASH_TYPE_PDFU16;
9720 salt_type = SALT_TYPE_EMBEDDED;
9721 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9722 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9723 kern_type = KERN_TYPE_PDF11;
9724 dgst_size = DGST_SIZE_4_4;
9725 parse_func = pdf11_parse_hash;
9726 sort_by_digest = sort_by_digest_4_4;
9727 opti_type = OPTI_TYPE_ZERO_BYTE
9728 | OPTI_TYPE_NOT_ITERATED;
9729 dgst_pos0 = 0;
9730 dgst_pos1 = 1;
9731 dgst_pos2 = 2;
9732 dgst_pos3 = 3;
9733 break;
9734
9735 case 10410: hash_type = HASH_TYPE_PDFU16;
9736 salt_type = SALT_TYPE_EMBEDDED;
9737 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9738 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9739 kern_type = KERN_TYPE_PDF11CM1;
9740 dgst_size = DGST_SIZE_4_4;
9741 parse_func = pdf11cm1_parse_hash;
9742 sort_by_digest = sort_by_digest_4_4;
9743 opti_type = OPTI_TYPE_ZERO_BYTE
9744 | OPTI_TYPE_NOT_ITERATED;
9745 dgst_pos0 = 0;
9746 dgst_pos1 = 1;
9747 dgst_pos2 = 2;
9748 dgst_pos3 = 3;
9749 break;
9750
9751 case 10420: hash_type = HASH_TYPE_PDFU16;
9752 salt_type = SALT_TYPE_EMBEDDED;
9753 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9754 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9755 kern_type = KERN_TYPE_PDF11CM2;
9756 dgst_size = DGST_SIZE_4_4;
9757 parse_func = pdf11cm2_parse_hash;
9758 sort_by_digest = sort_by_digest_4_4;
9759 opti_type = OPTI_TYPE_ZERO_BYTE
9760 | OPTI_TYPE_NOT_ITERATED;
9761 dgst_pos0 = 0;
9762 dgst_pos1 = 1;
9763 dgst_pos2 = 2;
9764 dgst_pos3 = 3;
9765 break;
9766
9767 case 10500: hash_type = HASH_TYPE_PDFU16;
9768 salt_type = SALT_TYPE_EMBEDDED;
9769 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9770 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9771 kern_type = KERN_TYPE_PDF14;
9772 dgst_size = DGST_SIZE_4_4;
9773 parse_func = pdf14_parse_hash;
9774 sort_by_digest = sort_by_digest_4_4;
9775 opti_type = OPTI_TYPE_ZERO_BYTE
9776 | OPTI_TYPE_NOT_ITERATED;
9777 dgst_pos0 = 0;
9778 dgst_pos1 = 1;
9779 dgst_pos2 = 2;
9780 dgst_pos3 = 3;
9781 break;
9782
9783 case 10600: hash_type = HASH_TYPE_SHA256;
9784 salt_type = SALT_TYPE_EMBEDDED;
9785 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9786 opts_type = OPTS_TYPE_PT_GENERATE_BE
9787 | OPTS_TYPE_ST_ADD80
9788 | OPTS_TYPE_ST_ADDBITS15
9789 | OPTS_TYPE_HASH_COPY;
9790 kern_type = KERN_TYPE_SHA256_PWSLT;
9791 dgst_size = DGST_SIZE_4_8;
9792 parse_func = pdf17l3_parse_hash;
9793 sort_by_digest = sort_by_digest_4_8;
9794 opti_type = OPTI_TYPE_ZERO_BYTE
9795 | OPTI_TYPE_PRECOMPUTE_INIT
9796 | OPTI_TYPE_PRECOMPUTE_MERKLE
9797 | OPTI_TYPE_EARLY_SKIP
9798 | OPTI_TYPE_NOT_ITERATED
9799 | OPTI_TYPE_APPENDED_SALT
9800 | OPTI_TYPE_RAW_HASH;
9801 dgst_pos0 = 3;
9802 dgst_pos1 = 7;
9803 dgst_pos2 = 2;
9804 dgst_pos3 = 6;
9805 break;
9806
9807 case 10700: hash_type = HASH_TYPE_PDFU32;
9808 salt_type = SALT_TYPE_EMBEDDED;
9809 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9810 opts_type = OPTS_TYPE_PT_GENERATE_LE
9811 | OPTS_TYPE_HASH_COPY;
9812 kern_type = KERN_TYPE_PDF17L8;
9813 dgst_size = DGST_SIZE_4_8;
9814 parse_func = pdf17l8_parse_hash;
9815 sort_by_digest = sort_by_digest_4_8;
9816 opti_type = OPTI_TYPE_ZERO_BYTE
9817 | OPTI_TYPE_NOT_ITERATED;
9818 dgst_pos0 = 0;
9819 dgst_pos1 = 1;
9820 dgst_pos2 = 2;
9821 dgst_pos3 = 3;
9822 break;
9823
9824 case 10800: hash_type = HASH_TYPE_SHA384;
9825 salt_type = SALT_TYPE_NONE;
9826 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9827 opts_type = OPTS_TYPE_PT_GENERATE_BE
9828 | OPTS_TYPE_PT_ADD80
9829 | OPTS_TYPE_PT_ADDBITS15;
9830 kern_type = KERN_TYPE_SHA384;
9831 dgst_size = DGST_SIZE_8_8;
9832 parse_func = sha384_parse_hash;
9833 sort_by_digest = sort_by_digest_8_8;
9834 opti_type = OPTI_TYPE_ZERO_BYTE
9835 | OPTI_TYPE_PRECOMPUTE_INIT
9836 | OPTI_TYPE_PRECOMPUTE_MERKLE
9837 | OPTI_TYPE_EARLY_SKIP
9838 | OPTI_TYPE_NOT_ITERATED
9839 | OPTI_TYPE_NOT_SALTED
9840 | OPTI_TYPE_USES_BITS_64
9841 | OPTI_TYPE_RAW_HASH;
9842 dgst_pos0 = 6;
9843 dgst_pos1 = 7;
9844 dgst_pos2 = 4;
9845 dgst_pos3 = 5;
9846 break;
9847
9848 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9849 salt_type = SALT_TYPE_EMBEDDED;
9850 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9851 opts_type = OPTS_TYPE_PT_GENERATE_LE
9852 | OPTS_TYPE_ST_BASE64
9853 | OPTS_TYPE_HASH_COPY;
9854 kern_type = KERN_TYPE_PBKDF2_SHA256;
9855 dgst_size = DGST_SIZE_4_32;
9856 parse_func = pbkdf2_sha256_parse_hash;
9857 sort_by_digest = sort_by_digest_4_32;
9858 opti_type = OPTI_TYPE_ZERO_BYTE;
9859 dgst_pos0 = 0;
9860 dgst_pos1 = 1;
9861 dgst_pos2 = 2;
9862 dgst_pos3 = 3;
9863 break;
9864
9865 case 11000: hash_type = HASH_TYPE_MD5;
9866 salt_type = SALT_TYPE_INTERN;
9867 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9868 opts_type = OPTS_TYPE_PT_GENERATE_LE
9869 | OPTS_TYPE_PT_ADD80;
9870 kern_type = KERN_TYPE_PRESTASHOP;
9871 dgst_size = DGST_SIZE_4_4;
9872 parse_func = prestashop_parse_hash;
9873 sort_by_digest = sort_by_digest_4_4;
9874 opti_type = OPTI_TYPE_ZERO_BYTE
9875 | OPTI_TYPE_PRECOMPUTE_INIT
9876 | OPTI_TYPE_NOT_ITERATED
9877 | OPTI_TYPE_PREPENDED_SALT;
9878 dgst_pos0 = 0;
9879 dgst_pos1 = 3;
9880 dgst_pos2 = 2;
9881 dgst_pos3 = 1;
9882 break;
9883
9884 case 11100: hash_type = HASH_TYPE_MD5;
9885 salt_type = SALT_TYPE_EMBEDDED;
9886 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9887 opts_type = OPTS_TYPE_PT_GENERATE_LE
9888 | OPTS_TYPE_ST_ADD80;
9889 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9890 dgst_size = DGST_SIZE_4_4;
9891 parse_func = postgresql_auth_parse_hash;
9892 sort_by_digest = sort_by_digest_4_4;
9893 opti_type = OPTI_TYPE_ZERO_BYTE
9894 | OPTI_TYPE_PRECOMPUTE_INIT
9895 | OPTI_TYPE_PRECOMPUTE_MERKLE
9896 | OPTI_TYPE_EARLY_SKIP;
9897 dgst_pos0 = 0;
9898 dgst_pos1 = 3;
9899 dgst_pos2 = 2;
9900 dgst_pos3 = 1;
9901 break;
9902
9903 case 11200: hash_type = HASH_TYPE_SHA1;
9904 salt_type = SALT_TYPE_EMBEDDED;
9905 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9906 opts_type = OPTS_TYPE_PT_GENERATE_BE
9907 | OPTS_TYPE_PT_ADD80
9908 | OPTS_TYPE_ST_HEX;
9909 kern_type = KERN_TYPE_MYSQL_AUTH;
9910 dgst_size = DGST_SIZE_4_5;
9911 parse_func = mysql_auth_parse_hash;
9912 sort_by_digest = sort_by_digest_4_5;
9913 opti_type = OPTI_TYPE_ZERO_BYTE
9914 | OPTI_TYPE_EARLY_SKIP;
9915 dgst_pos0 = 3;
9916 dgst_pos1 = 4;
9917 dgst_pos2 = 2;
9918 dgst_pos3 = 1;
9919 break;
9920
9921 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9922 salt_type = SALT_TYPE_EMBEDDED;
9923 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9924 opts_type = OPTS_TYPE_PT_GENERATE_LE
9925 | OPTS_TYPE_ST_HEX
9926 | OPTS_TYPE_ST_ADD80;
9927 kern_type = KERN_TYPE_BITCOIN_WALLET;
9928 dgst_size = DGST_SIZE_4_4;
9929 parse_func = bitcoin_wallet_parse_hash;
9930 sort_by_digest = sort_by_digest_4_4;
9931 opti_type = OPTI_TYPE_ZERO_BYTE;
9932 dgst_pos0 = 0;
9933 dgst_pos1 = 1;
9934 dgst_pos2 = 2;
9935 dgst_pos3 = 3;
9936 break;
9937
9938 case 11400: hash_type = HASH_TYPE_MD5;
9939 salt_type = SALT_TYPE_EMBEDDED;
9940 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9941 opts_type = OPTS_TYPE_PT_GENERATE_LE
9942 | OPTS_TYPE_PT_ADD80
9943 | OPTS_TYPE_HASH_COPY;
9944 kern_type = KERN_TYPE_SIP_AUTH;
9945 dgst_size = DGST_SIZE_4_4;
9946 parse_func = sip_auth_parse_hash;
9947 sort_by_digest = sort_by_digest_4_4;
9948 opti_type = OPTI_TYPE_ZERO_BYTE;
9949 dgst_pos0 = 0;
9950 dgst_pos1 = 3;
9951 dgst_pos2 = 2;
9952 dgst_pos3 = 1;
9953 break;
9954
9955 case 11500: hash_type = HASH_TYPE_CRC32;
9956 salt_type = SALT_TYPE_INTERN;
9957 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9958 opts_type = OPTS_TYPE_PT_GENERATE_LE
9959 | OPTS_TYPE_ST_GENERATE_LE
9960 | OPTS_TYPE_ST_HEX;
9961 kern_type = KERN_TYPE_CRC32;
9962 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9963 parse_func = crc32_parse_hash;
9964 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
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 11600: hash_type = HASH_TYPE_AES;
9973 salt_type = SALT_TYPE_EMBEDDED;
9974 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9975 opts_type = OPTS_TYPE_PT_GENERATE_LE
9976 | OPTS_TYPE_PT_NEVERCRACK;
9977 kern_type = KERN_TYPE_SEVEN_ZIP;
9978 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9979 parse_func = seven_zip_parse_hash;
9980 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9981 opti_type = OPTI_TYPE_ZERO_BYTE;
9982 dgst_pos0 = 0;
9983 dgst_pos1 = 1;
9984 dgst_pos2 = 2;
9985 dgst_pos3 = 3;
9986 break;
9987
9988 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9989 salt_type = SALT_TYPE_NONE;
9990 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9991 opts_type = OPTS_TYPE_PT_GENERATE_LE
9992 | OPTS_TYPE_PT_ADD01;
9993 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9994 dgst_size = DGST_SIZE_4_8;
9995 parse_func = gost2012sbog_256_parse_hash;
9996 sort_by_digest = sort_by_digest_4_8;
9997 opti_type = OPTI_TYPE_ZERO_BYTE;
9998 dgst_pos0 = 0;
9999 dgst_pos1 = 1;
10000 dgst_pos2 = 2;
10001 dgst_pos3 = 3;
10002 break;
10003
10004 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10005 salt_type = SALT_TYPE_NONE;
10006 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10007 opts_type = OPTS_TYPE_PT_GENERATE_LE
10008 | OPTS_TYPE_PT_ADD01;
10009 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10010 dgst_size = DGST_SIZE_4_16;
10011 parse_func = gost2012sbog_512_parse_hash;
10012 sort_by_digest = sort_by_digest_4_16;
10013 opti_type = OPTI_TYPE_ZERO_BYTE;
10014 dgst_pos0 = 0;
10015 dgst_pos1 = 1;
10016 dgst_pos2 = 2;
10017 dgst_pos3 = 3;
10018 break;
10019
10020 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10021 salt_type = SALT_TYPE_EMBEDDED;
10022 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10023 opts_type = OPTS_TYPE_PT_GENERATE_LE
10024 | OPTS_TYPE_ST_BASE64
10025 | OPTS_TYPE_HASH_COPY;
10026 kern_type = KERN_TYPE_PBKDF2_MD5;
10027 dgst_size = DGST_SIZE_4_32;
10028 parse_func = pbkdf2_md5_parse_hash;
10029 sort_by_digest = sort_by_digest_4_32;
10030 opti_type = OPTI_TYPE_ZERO_BYTE;
10031 dgst_pos0 = 0;
10032 dgst_pos1 = 1;
10033 dgst_pos2 = 2;
10034 dgst_pos3 = 3;
10035 break;
10036
10037 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10038 salt_type = SALT_TYPE_EMBEDDED;
10039 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10040 opts_type = OPTS_TYPE_PT_GENERATE_LE
10041 | OPTS_TYPE_ST_BASE64
10042 | OPTS_TYPE_HASH_COPY;
10043 kern_type = KERN_TYPE_PBKDF2_SHA1;
10044 dgst_size = DGST_SIZE_4_32;
10045 parse_func = pbkdf2_sha1_parse_hash;
10046 sort_by_digest = sort_by_digest_4_32;
10047 opti_type = OPTI_TYPE_ZERO_BYTE;
10048 dgst_pos0 = 0;
10049 dgst_pos1 = 1;
10050 dgst_pos2 = 2;
10051 dgst_pos3 = 3;
10052 break;
10053
10054 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10055 salt_type = SALT_TYPE_EMBEDDED;
10056 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10057 opts_type = OPTS_TYPE_PT_GENERATE_LE
10058 | OPTS_TYPE_ST_BASE64
10059 | OPTS_TYPE_HASH_COPY;
10060 kern_type = KERN_TYPE_PBKDF2_SHA512;
10061 dgst_size = DGST_SIZE_8_16;
10062 parse_func = pbkdf2_sha512_parse_hash;
10063 sort_by_digest = sort_by_digest_8_16;
10064 opti_type = OPTI_TYPE_ZERO_BYTE
10065 | OPTI_TYPE_USES_BITS_64;
10066 dgst_pos0 = 0;
10067 dgst_pos1 = 1;
10068 dgst_pos2 = 2;
10069 dgst_pos3 = 3;
10070 break;
10071
10072 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10073 salt_type = SALT_TYPE_EMBEDDED;
10074 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10075 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10076 kern_type = KERN_TYPE_ECRYPTFS;
10077 dgst_size = DGST_SIZE_8_8;
10078 parse_func = ecryptfs_parse_hash;
10079 sort_by_digest = sort_by_digest_8_8;
10080 opti_type = OPTI_TYPE_ZERO_BYTE
10081 | OPTI_TYPE_USES_BITS_64;
10082 dgst_pos0 = 0;
10083 dgst_pos1 = 1;
10084 dgst_pos2 = 2;
10085 dgst_pos3 = 3;
10086 break;
10087
10088 case 12300: hash_type = HASH_TYPE_ORACLET;
10089 salt_type = SALT_TYPE_EMBEDDED;
10090 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10091 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10092 kern_type = KERN_TYPE_ORACLET;
10093 dgst_size = DGST_SIZE_8_16;
10094 parse_func = oraclet_parse_hash;
10095 sort_by_digest = sort_by_digest_8_16;
10096 opti_type = OPTI_TYPE_ZERO_BYTE
10097 | OPTI_TYPE_USES_BITS_64;
10098 dgst_pos0 = 0;
10099 dgst_pos1 = 1;
10100 dgst_pos2 = 2;
10101 dgst_pos3 = 3;
10102 break;
10103
10104 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10105 salt_type = SALT_TYPE_EMBEDDED;
10106 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10107 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10108 kern_type = KERN_TYPE_BSDICRYPT;
10109 dgst_size = DGST_SIZE_4_4;
10110 parse_func = bsdicrypt_parse_hash;
10111 sort_by_digest = sort_by_digest_4_4;
10112 opti_type = OPTI_TYPE_ZERO_BYTE
10113 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10114 dgst_pos0 = 0;
10115 dgst_pos1 = 1;
10116 dgst_pos2 = 2;
10117 dgst_pos3 = 3;
10118 break;
10119
10120 case 12500: hash_type = HASH_TYPE_RAR3HP;
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_RAR3;
10125 dgst_size = DGST_SIZE_4_4;
10126 parse_func = rar3hp_parse_hash;
10127 sort_by_digest = sort_by_digest_4_4;
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 12600: hash_type = HASH_TYPE_SHA256;
10136 salt_type = SALT_TYPE_INTERN;
10137 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10138 opts_type = OPTS_TYPE_PT_GENERATE_BE
10139 | OPTS_TYPE_PT_ADD80;
10140 kern_type = KERN_TYPE_CF10;
10141 dgst_size = DGST_SIZE_4_8;
10142 parse_func = cf10_parse_hash;
10143 sort_by_digest = sort_by_digest_4_8;
10144 opti_type = OPTI_TYPE_ZERO_BYTE
10145 | OPTI_TYPE_PRECOMPUTE_INIT
10146 | OPTI_TYPE_EARLY_SKIP
10147 | OPTI_TYPE_NOT_ITERATED;
10148 dgst_pos0 = 3;
10149 dgst_pos1 = 7;
10150 dgst_pos2 = 2;
10151 dgst_pos3 = 6;
10152 break;
10153
10154 case 12700: hash_type = HASH_TYPE_AES;
10155 salt_type = SALT_TYPE_EMBEDDED;
10156 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10157 opts_type = OPTS_TYPE_PT_GENERATE_LE
10158 | OPTS_TYPE_HASH_COPY;
10159 kern_type = KERN_TYPE_MYWALLET;
10160 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10161 parse_func = mywallet_parse_hash;
10162 sort_by_digest = sort_by_digest_4_5;
10163 opti_type = OPTI_TYPE_ZERO_BYTE;
10164 dgst_pos0 = 0;
10165 dgst_pos1 = 1;
10166 dgst_pos2 = 2;
10167 dgst_pos3 = 3;
10168 break;
10169
10170 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10171 salt_type = SALT_TYPE_EMBEDDED;
10172 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10173 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10174 kern_type = KERN_TYPE_MS_DRSR;
10175 dgst_size = DGST_SIZE_4_8;
10176 parse_func = ms_drsr_parse_hash;
10177 sort_by_digest = sort_by_digest_4_8;
10178 opti_type = OPTI_TYPE_ZERO_BYTE;
10179 dgst_pos0 = 0;
10180 dgst_pos1 = 1;
10181 dgst_pos2 = 2;
10182 dgst_pos3 = 3;
10183 break;
10184
10185 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10186 salt_type = SALT_TYPE_EMBEDDED;
10187 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10188 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10189 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10190 dgst_size = DGST_SIZE_4_8;
10191 parse_func = androidfde_samsung_parse_hash;
10192 sort_by_digest = sort_by_digest_4_8;
10193 opti_type = OPTI_TYPE_ZERO_BYTE;
10194 dgst_pos0 = 0;
10195 dgst_pos1 = 1;
10196 dgst_pos2 = 2;
10197 dgst_pos3 = 3;
10198 break;
10199
10200 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10201 salt_type = SALT_TYPE_EMBEDDED;
10202 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10203 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10204 kern_type = KERN_TYPE_RAR5;
10205 dgst_size = DGST_SIZE_4_4;
10206 parse_func = rar5_parse_hash;
10207 sort_by_digest = sort_by_digest_4_4;
10208 opti_type = OPTI_TYPE_ZERO_BYTE;
10209 dgst_pos0 = 0;
10210 dgst_pos1 = 1;
10211 dgst_pos2 = 2;
10212 dgst_pos3 = 3;
10213 break;
10214
10215 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10216 salt_type = SALT_TYPE_EMBEDDED;
10217 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10218 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10219 kern_type = KERN_TYPE_KRB5TGS;
10220 dgst_size = DGST_SIZE_4_4;
10221 parse_func = krb5tgs_parse_hash;
10222 sort_by_digest = sort_by_digest_4_4;
10223 opti_type = OPTI_TYPE_ZERO_BYTE
10224 | OPTI_TYPE_NOT_ITERATED;
10225 dgst_pos0 = 0;
10226 dgst_pos1 = 1;
10227 dgst_pos2 = 2;
10228 dgst_pos3 = 3;
10229 break;
10230
10231 case 13200: hash_type = HASH_TYPE_AES;
10232 salt_type = SALT_TYPE_EMBEDDED;
10233 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10234 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10235 kern_type = KERN_TYPE_AXCRYPT;
10236 dgst_size = DGST_SIZE_4_4;
10237 parse_func = axcrypt_parse_hash;
10238 sort_by_digest = sort_by_digest_4_4;
10239 opti_type = OPTI_TYPE_ZERO_BYTE;
10240 dgst_pos0 = 0;
10241 dgst_pos1 = 1;
10242 dgst_pos2 = 2;
10243 dgst_pos3 = 3;
10244 break;
10245
10246 case 13300: hash_type = HASH_TYPE_SHA1;
10247 salt_type = SALT_TYPE_NONE;
10248 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10249 opts_type = OPTS_TYPE_PT_GENERATE_BE
10250 | OPTS_TYPE_PT_ADD80
10251 | OPTS_TYPE_PT_ADDBITS15;
10252 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10253 dgst_size = DGST_SIZE_4_5;
10254 parse_func = sha1axcrypt_parse_hash;
10255 sort_by_digest = sort_by_digest_4_5;
10256 opti_type = OPTI_TYPE_ZERO_BYTE
10257 | OPTI_TYPE_PRECOMPUTE_INIT
10258 | OPTI_TYPE_EARLY_SKIP
10259 | OPTI_TYPE_NOT_ITERATED
10260 | OPTI_TYPE_NOT_SALTED;
10261 dgst_pos0 = 0;
10262 dgst_pos1 = 4;
10263 dgst_pos2 = 3;
10264 dgst_pos3 = 2;
10265 break;
10266
10267 default: usage_mini_print (PROGNAME); return (-1);
10268 }
10269
10270 /**
10271 * parser
10272 */
10273
10274 data.parse_func = parse_func;
10275
10276 /**
10277 * misc stuff
10278 */
10279
10280 if (hex_salt)
10281 {
10282 if (salt_type == SALT_TYPE_INTERN)
10283 {
10284 opts_type |= OPTS_TYPE_ST_HEX;
10285 }
10286 else
10287 {
10288 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10289
10290 return (-1);
10291 }
10292 }
10293
10294 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10295 | (salt_type == SALT_TYPE_EXTERN)
10296 | (salt_type == SALT_TYPE_EMBEDDED)
10297 | (salt_type == SALT_TYPE_VIRTUAL));
10298
10299 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10300
10301 data.hash_type = hash_type;
10302 data.attack_mode = attack_mode;
10303 data.attack_kern = attack_kern;
10304 data.attack_exec = attack_exec;
10305 data.kern_type = kern_type;
10306 data.opts_type = opts_type;
10307 data.dgst_size = dgst_size;
10308 data.salt_type = salt_type;
10309 data.isSalted = isSalted;
10310 data.sort_by_digest = sort_by_digest;
10311 data.dgst_pos0 = dgst_pos0;
10312 data.dgst_pos1 = dgst_pos1;
10313 data.dgst_pos2 = dgst_pos2;
10314 data.dgst_pos3 = dgst_pos3;
10315
10316 esalt_size = 0;
10317
10318 switch (hash_mode)
10319 {
10320 case 2500: esalt_size = sizeof (wpa_t); break;
10321 case 5300: esalt_size = sizeof (ikepsk_t); break;
10322 case 5400: esalt_size = sizeof (ikepsk_t); break;
10323 case 5500: esalt_size = sizeof (netntlm_t); break;
10324 case 5600: esalt_size = sizeof (netntlm_t); break;
10325 case 6211: esalt_size = sizeof (tc_t); break;
10326 case 6212: esalt_size = sizeof (tc_t); break;
10327 case 6213: esalt_size = sizeof (tc_t); break;
10328 case 6221: esalt_size = sizeof (tc_t); break;
10329 case 6222: esalt_size = sizeof (tc_t); break;
10330 case 6223: esalt_size = sizeof (tc_t); break;
10331 case 6231: esalt_size = sizeof (tc_t); break;
10332 case 6232: esalt_size = sizeof (tc_t); break;
10333 case 6233: esalt_size = sizeof (tc_t); break;
10334 case 6241: esalt_size = sizeof (tc_t); break;
10335 case 6242: esalt_size = sizeof (tc_t); break;
10336 case 6243: esalt_size = sizeof (tc_t); break;
10337 case 6600: esalt_size = sizeof (agilekey_t); break;
10338 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10339 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10340 case 7300: esalt_size = sizeof (rakp_t); break;
10341 case 7500: esalt_size = sizeof (krb5pa_t); break;
10342 case 8200: esalt_size = sizeof (cloudkey_t); break;
10343 case 8800: esalt_size = sizeof (androidfde_t); break;
10344 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10345 case 9400: esalt_size = sizeof (office2007_t); break;
10346 case 9500: esalt_size = sizeof (office2010_t); break;
10347 case 9600: esalt_size = sizeof (office2013_t); break;
10348 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10349 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10350 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10351 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10352 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10353 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10354 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10355 case 10200: esalt_size = sizeof (cram_md5_t); break;
10356 case 10400: esalt_size = sizeof (pdf_t); break;
10357 case 10410: esalt_size = sizeof (pdf_t); break;
10358 case 10420: esalt_size = sizeof (pdf_t); break;
10359 case 10500: esalt_size = sizeof (pdf_t); break;
10360 case 10600: esalt_size = sizeof (pdf_t); break;
10361 case 10700: esalt_size = sizeof (pdf_t); break;
10362 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10363 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10364 case 11400: esalt_size = sizeof (sip_t); break;
10365 case 11600: esalt_size = sizeof (seven_zip_t); break;
10366 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10367 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10368 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10369 case 13000: esalt_size = sizeof (rar5_t); break;
10370 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10371 }
10372
10373 data.esalt_size = esalt_size;
10374
10375 /**
10376 * choose dictionary parser
10377 */
10378
10379 if (hash_type == HASH_TYPE_LM)
10380 {
10381 get_next_word_func = get_next_word_lm;
10382 }
10383 else if (opts_type & OPTS_TYPE_PT_UPPER)
10384 {
10385 get_next_word_func = get_next_word_uc;
10386 }
10387 else
10388 {
10389 get_next_word_func = get_next_word_std;
10390 }
10391
10392 /**
10393 * dictstat
10394 */
10395
10396 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10397
10398 #ifdef _POSIX
10399 size_t dictstat_nmemb = 0;
10400 #endif
10401
10402 #ifdef _WIN
10403 uint dictstat_nmemb = 0;
10404 #endif
10405
10406 char dictstat[256] = { 0 };
10407
10408 FILE *dictstat_fp = NULL;
10409
10410 if (keyspace == 0)
10411 {
10412 snprintf (dictstat, sizeof (dictstat) - 1, "%s/hashcat.dictstat", profile_dir);
10413
10414 dictstat_fp = fopen (dictstat, "rb");
10415
10416 if (dictstat_fp)
10417 {
10418 #ifdef _POSIX
10419 struct stat tmpstat;
10420
10421 fstat (fileno (dictstat_fp), &tmpstat);
10422 #endif
10423
10424 #ifdef _WIN
10425 struct stat64 tmpstat;
10426
10427 _fstat64 (fileno (dictstat_fp), &tmpstat);
10428 #endif
10429
10430 if (tmpstat.st_mtime < COMPTIME)
10431 {
10432 /* with v0.15 the format changed so we have to ensure user is using a good version
10433 since there is no version-header in the dictstat file */
10434
10435 fclose (dictstat_fp);
10436
10437 unlink (dictstat);
10438 }
10439 else
10440 {
10441 while (!feof (dictstat_fp))
10442 {
10443 dictstat_t d;
10444
10445 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10446
10447 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10448
10449 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10450 {
10451 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10452
10453 return -1;
10454 }
10455 }
10456
10457 fclose (dictstat_fp);
10458 }
10459 }
10460 }
10461
10462 /**
10463 * potfile
10464 */
10465
10466 char potfile[256] = { 0 };
10467
10468 snprintf (potfile, sizeof (potfile) - 1, "%s/%s.pot", session_dir, session);
10469
10470 data.pot_fp = NULL;
10471
10472 FILE *out_fp = NULL;
10473 FILE *pot_fp = NULL;
10474
10475 if (show == 1 || left == 1)
10476 {
10477 pot_fp = fopen (potfile, "rb");
10478
10479 if (pot_fp == NULL)
10480 {
10481 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10482
10483 return (-1);
10484 }
10485
10486 if (outfile != NULL)
10487 {
10488 if ((out_fp = fopen (outfile, "ab")) == NULL)
10489 {
10490 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10491
10492 fclose (pot_fp);
10493
10494 return (-1);
10495 }
10496 }
10497 else
10498 {
10499 out_fp = stdout;
10500 }
10501 }
10502 else
10503 {
10504 if (potfile_disable == 0)
10505 {
10506 pot_fp = fopen (potfile, "ab");
10507
10508 if (pot_fp == NULL)
10509 {
10510 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10511
10512 return (-1);
10513 }
10514
10515 data.pot_fp = pot_fp;
10516 }
10517 }
10518
10519 pot_t *pot = NULL;
10520
10521 uint pot_cnt = 0;
10522 uint pot_avail = 0;
10523
10524 if (show == 1 || left == 1)
10525 {
10526 SUPPRESS_OUTPUT = 1;
10527
10528 pot_avail = count_lines (pot_fp);
10529
10530 rewind (pot_fp);
10531
10532 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10533
10534 uint pot_hashes_avail = 0;
10535
10536 uint line_num = 0;
10537
10538 char *line_buf = (char *) mymalloc (HCBUFSIZ);
10539
10540 while (!feof (pot_fp))
10541 {
10542 line_num++;
10543
10544 int line_len = fgetl (pot_fp, line_buf);
10545
10546 if (line_len == 0) continue;
10547
10548 char *plain_buf = line_buf + line_len;
10549
10550 pot_t *pot_ptr = &pot[pot_cnt];
10551
10552 hash_t *hashes_buf = &pot_ptr->hash;
10553
10554 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10555 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10556
10557 if (pot_cnt == pot_hashes_avail)
10558 {
10559 uint pos = 0;
10560
10561 for (pos = 0; pos < INCR_POT; pos++)
10562 {
10563 if ((pot_cnt + pos) >= pot_avail) break;
10564
10565 pot_t *tmp_pot = &pot[pot_cnt + pos];
10566
10567 hash_t *tmp_hash = &tmp_pot->hash;
10568
10569 tmp_hash->digest = mymalloc (dgst_size);
10570
10571 if (isSalted)
10572 {
10573 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10574 }
10575
10576 if (esalt_size)
10577 {
10578 tmp_hash->esalt = mymalloc (esalt_size);
10579 }
10580
10581 pot_hashes_avail++;
10582 }
10583 }
10584
10585 int plain_len = 0;
10586
10587 int parser_status;
10588
10589 int iter = MAX_CUT_TRIES;
10590
10591 do
10592 {
10593 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10594 {
10595 if (line_buf[i] == ':')
10596 {
10597 line_len--;
10598
10599 break;
10600 }
10601 }
10602
10603 if (data.hash_mode != 2500)
10604 {
10605 parser_status = parse_func (line_buf, line_len, hashes_buf);
10606 }
10607 else
10608 {
10609 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10610
10611 if (line_len > max_salt_size)
10612 {
10613 parser_status = PARSER_GLOBAL_LENGTH;
10614 }
10615 else
10616 {
10617 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10618
10619 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10620
10621 hashes_buf->salt->salt_len = line_len;
10622
10623 parser_status = PARSER_OK;
10624 }
10625 }
10626
10627 // if NOT parsed without error, we add the ":" to the plain
10628
10629 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10630 {
10631 plain_len++;
10632 plain_buf--;
10633 }
10634
10635 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10636
10637 if (parser_status < PARSER_GLOBAL_ZERO)
10638 {
10639 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10640
10641 continue;
10642 }
10643
10644 if (plain_len >= 255) continue;
10645
10646 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10647
10648 pot_ptr->plain_len = plain_len;
10649
10650 pot_cnt++;
10651 }
10652
10653 myfree (line_buf);
10654
10655 fclose (pot_fp);
10656
10657 SUPPRESS_OUTPUT = 0;
10658
10659 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10660 }
10661
10662 /**
10663 * word len
10664 */
10665
10666 uint pw_min = PW_MIN;
10667 uint pw_max = PW_MAX;
10668
10669 switch (hash_mode)
10670 {
10671 case 400: if (pw_max > 40) pw_max = 40;
10672 break;
10673 case 500: if (pw_max > 16) pw_max = 16;
10674 break;
10675 case 1500: if (pw_max > 8) pw_max = 8;
10676 break;
10677 case 1600: if (pw_max > 16) pw_max = 16;
10678 break;
10679 case 1800: if (pw_max > 16) pw_max = 16;
10680 break;
10681 case 2100: if (pw_max > 16) pw_max = 16;
10682 break;
10683 case 2500: if (pw_min < 8) pw_min = 8;
10684 break;
10685 case 3000: if (pw_max > 7) pw_max = 7;
10686 break;
10687 case 5200: if (pw_max > 24) pw_max = 24;
10688 break;
10689 case 5800: if (pw_max > 16) pw_max = 16;
10690 break;
10691 case 6300: if (pw_max > 16) pw_max = 16;
10692 break;
10693 case 7400: if (pw_max > 16) pw_max = 16;
10694 break;
10695 case 7900: if (pw_max > 48) pw_max = 48;
10696 break;
10697 case 8500: if (pw_max > 8) pw_max = 8;
10698 break;
10699 case 8600: if (pw_max > 16) pw_max = 16;
10700 break;
10701 case 9710: pw_min = 5;
10702 pw_max = 5;
10703 break;
10704 case 9810: pw_min = 5;
10705 pw_max = 5;
10706 break;
10707 case 10410: pw_min = 5;
10708 pw_max = 5;
10709 break;
10710 case 10300: if (pw_max < 3) pw_min = 3;
10711 if (pw_max > 40) pw_max = 40;
10712 break;
10713 case 10500: if (pw_max < 3) pw_min = 3;
10714 if (pw_max > 40) pw_max = 40;
10715 break;
10716 case 10700: if (pw_max > 16) pw_max = 16;
10717 break;
10718 case 11300: if (pw_max > 40) pw_max = 40;
10719 break;
10720 case 12500: if (pw_max > 20) pw_max = 20;
10721 break;
10722 case 12800: if (pw_max > 24) pw_max = 24;
10723 break;
10724 }
10725
10726 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10727 {
10728 switch (attack_kern)
10729 {
10730 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10731 break;
10732 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10733 break;
10734 }
10735 }
10736
10737 /**
10738 * charsets : keep them together for more easy maintainnce
10739 */
10740
10741 cs_t mp_sys[6] = { { { 0 }, 0 } };
10742 cs_t mp_usr[4] = { { { 0 }, 0 } };
10743
10744 mp_setup_sys (mp_sys);
10745
10746 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10747 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10748 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10749 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10750
10751 /**
10752 * load hashes, part I: find input mode, count hashes
10753 */
10754
10755 uint hashlist_mode = 0;
10756 uint hashlist_format = HLFMT_HASHCAT;
10757
10758 uint hashes_avail = 0;
10759
10760 if (benchmark == 0)
10761 {
10762 struct stat f;
10763
10764 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10765
10766 if ((hash_mode == 2500) ||
10767 (hash_mode == 5200) ||
10768 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10769 (hash_mode == 9000))
10770 {
10771 hashlist_mode = HL_MODE_ARG;
10772
10773 char *hashfile = myargv[optind];
10774
10775 data.hashfile = hashfile;
10776
10777 logfile_top_var_string ("target", hashfile);
10778 }
10779
10780 if (hashlist_mode == HL_MODE_ARG)
10781 {
10782 if (hash_mode == 2500)
10783 {
10784 struct stat st;
10785
10786 if (stat (data.hashfile, &st) == -1)
10787 {
10788 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10789
10790 return (-1);
10791 }
10792
10793 hashes_avail = st.st_size / sizeof (hccap_t);
10794 }
10795 else
10796 {
10797 hashes_avail = 1;
10798 }
10799 }
10800 else if (hashlist_mode == HL_MODE_FILE)
10801 {
10802 char *hashfile = myargv[optind];
10803
10804 data.hashfile = hashfile;
10805
10806 logfile_top_var_string ("target", hashfile);
10807
10808 FILE *fp = NULL;
10809
10810 if ((fp = fopen (hashfile, "rb")) == NULL)
10811 {
10812 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10813
10814 return (-1);
10815 }
10816
10817 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10818
10819 hashes_avail = count_lines (fp);
10820
10821 rewind (fp);
10822
10823 if (hashes_avail == 0)
10824 {
10825 log_error ("ERROR: hashfile is empty or corrupt");
10826
10827 fclose (fp);
10828
10829 return (-1);
10830 }
10831
10832 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10833
10834 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10835 {
10836 log_error ("ERROR: remove not supported in native hashfile-format mode");
10837
10838 fclose (fp);
10839
10840 return (-1);
10841 }
10842
10843 fclose (fp);
10844 }
10845 }
10846 else
10847 {
10848 hashlist_mode = HL_MODE_ARG;
10849
10850 hashes_avail = 1;
10851 }
10852
10853 if (hash_mode == 3000) hashes_avail *= 2;
10854
10855 data.hashlist_mode = hashlist_mode;
10856 data.hashlist_format = hashlist_format;
10857
10858 logfile_top_uint (hashlist_mode);
10859 logfile_top_uint (hashlist_format);
10860
10861 /**
10862 * load hashes, part II: allocate required memory, set pointers
10863 */
10864
10865 hash_t *hashes_buf = NULL;
10866 void *digests_buf = NULL;
10867 salt_t *salts_buf = NULL;
10868 void *esalts_buf = NULL;
10869
10870 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10871
10872 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10873
10874 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10875 {
10876 u32 hash_pos;
10877
10878 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10879 {
10880 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10881
10882 hashes_buf[hash_pos].hash_info = hash_info;
10883
10884 if (username && (remove || show || left))
10885 {
10886 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10887 }
10888
10889 if (benchmark)
10890 {
10891 hash_info->orighash = (char *) mymalloc (256);
10892 }
10893 }
10894 }
10895
10896 if (isSalted)
10897 {
10898 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10899
10900 if (esalt_size)
10901 {
10902 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10903 }
10904 }
10905 else
10906 {
10907 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10908 }
10909
10910 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10911 {
10912 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10913
10914 if (isSalted)
10915 {
10916 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10917
10918 if (esalt_size)
10919 {
10920 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10921 }
10922 }
10923 else
10924 {
10925 hashes_buf[hash_pos].salt = &salts_buf[0];
10926 }
10927 }
10928
10929 /**
10930 * load hashes, part III: parse hashes or generate them if benchmark
10931 */
10932
10933 uint hashes_cnt = 0;
10934
10935 if (benchmark == 0)
10936 {
10937 if (keyspace == 1)
10938 {
10939 // useless to read hash file for keyspace, cheat a little bit w/ optind
10940 }
10941 else if (hashes_avail == 0)
10942 {
10943 }
10944 else if (hashlist_mode == HL_MODE_ARG)
10945 {
10946 char *input_buf = myargv[optind];
10947
10948 uint input_len = strlen (input_buf);
10949
10950 logfile_top_var_string ("target", input_buf);
10951
10952 char *hash_buf = NULL;
10953 int hash_len = 0;
10954
10955 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10956
10957 bool hash_fmt_error = 0;
10958
10959 if (hash_len < 1) hash_fmt_error = 1;
10960 if (hash_buf == NULL) hash_fmt_error = 1;
10961
10962 if (hash_fmt_error)
10963 {
10964 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
10965 }
10966 else
10967 {
10968 if (opts_type & OPTS_TYPE_HASH_COPY)
10969 {
10970 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10971
10972 hash_info_tmp->orighash = mystrdup (hash_buf);
10973 }
10974
10975 if (isSalted)
10976 {
10977 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
10978 }
10979
10980 int parser_status = PARSER_OK;
10981
10982 if (hash_mode == 2500)
10983 {
10984 if (hash_len == 0)
10985 {
10986 log_error ("ERROR: hccap file not specified");
10987
10988 return (-1);
10989 }
10990
10991 hashlist_mode = HL_MODE_FILE;
10992
10993 data.hashlist_mode = hashlist_mode;
10994
10995 FILE *fp = fopen (hash_buf, "rb");
10996
10997 if (fp == NULL)
10998 {
10999 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11000
11001 return (-1);
11002 }
11003
11004 if (hashes_avail < 1)
11005 {
11006 log_error ("ERROR: hccap file is empty or corrupt");
11007
11008 fclose (fp);
11009
11010 return (-1);
11011 }
11012
11013 uint hccap_size = sizeof (hccap_t);
11014
11015 char *in = (char *) mymalloc (hccap_size);
11016
11017 while (!feof (fp))
11018 {
11019 int n = fread (in, hccap_size, 1, fp);
11020
11021 if (n != 1)
11022 {
11023 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11024
11025 break;
11026 }
11027
11028 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11029
11030 if (parser_status != PARSER_OK)
11031 {
11032 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11033
11034 continue;
11035 }
11036
11037 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11038
11039 if ((show == 1) || (left == 1))
11040 {
11041 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11042
11043 char *salt_ptr = (char *) tmp_salt->salt_buf;
11044
11045 int cur_pos = tmp_salt->salt_len;
11046 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11047
11048 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11049
11050 u8 *pke_ptr = (u8 *) wpa->pke;
11051
11052 // do the appending task
11053
11054 snprintf (salt_ptr + cur_pos,
11055 rem_len,
11056 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11057 pke_ptr[20], pke_ptr[27], pke_ptr[26], pke_ptr[25], pke_ptr[24], pke_ptr[31], // MAC1
11058 pke_ptr[30], pke_ptr[29], pke_ptr[28], pke_ptr[35], pke_ptr[34], pke_ptr[33]); // MAC2
11059
11060
11061 // memset () the remaining part of the salt
11062
11063 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11064 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11065
11066 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11067
11068 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11069 }
11070
11071 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);
11072 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);
11073
11074 hashes_cnt++;
11075 }
11076
11077 fclose (fp);
11078
11079 myfree (in);
11080 }
11081 else if (hash_mode == 3000)
11082 {
11083 if (hash_len == 32)
11084 {
11085 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11086
11087 hash_t *lm_hash_left = NULL;
11088
11089 if (parser_status == PARSER_OK)
11090 {
11091 lm_hash_left = &hashes_buf[hashes_cnt];
11092
11093 hashes_cnt++;
11094 }
11095 else
11096 {
11097 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11098 }
11099
11100 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11101
11102 hash_t *lm_hash_right = NULL;
11103
11104 if (parser_status == PARSER_OK)
11105 {
11106 lm_hash_right = &hashes_buf[hashes_cnt];
11107
11108 hashes_cnt++;
11109 }
11110 else
11111 {
11112 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11113 }
11114
11115 // show / left
11116
11117 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11118 {
11119 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);
11120 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);
11121 }
11122 }
11123 else
11124 {
11125 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11126
11127 if (parser_status == PARSER_OK)
11128 {
11129 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11130 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11131 }
11132
11133 if (parser_status == PARSER_OK)
11134 {
11135 hashes_cnt++;
11136 }
11137 else
11138 {
11139 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11140 }
11141 }
11142 }
11143 else
11144 {
11145 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11146
11147 if (parser_status == PARSER_OK)
11148 {
11149 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11150 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11151 }
11152
11153 if (parser_status == PARSER_OK)
11154 {
11155 hashes_cnt++;
11156 }
11157 else
11158 {
11159 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11160 }
11161 }
11162 }
11163 }
11164 else if (hashlist_mode == HL_MODE_FILE)
11165 {
11166 char *hashfile = data.hashfile;
11167
11168 FILE *fp;
11169
11170 if ((fp = fopen (hashfile, "rb")) == NULL)
11171 {
11172 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11173
11174 return (-1);
11175 }
11176
11177 uint line_num = 0;
11178
11179 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11180
11181 while (!feof (fp))
11182 {
11183 line_num++;
11184
11185 int line_len = fgetl (fp, line_buf);
11186
11187 if (line_len == 0) continue;
11188
11189 char *hash_buf = NULL;
11190 int hash_len = 0;
11191
11192 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11193
11194 bool hash_fmt_error = 0;
11195
11196 if (hash_len < 1) hash_fmt_error = 1;
11197 if (hash_buf == NULL) hash_fmt_error = 1;
11198
11199 if (hash_fmt_error)
11200 {
11201 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11202
11203 continue;
11204 }
11205
11206 if (username)
11207 {
11208 char *user_buf = NULL;
11209 int user_len = 0;
11210
11211 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11212
11213 if (remove || show)
11214 {
11215 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11216
11217 *user = (user_t *) mymalloc (sizeof (user_t));
11218
11219 user_t *user_ptr = *user;
11220
11221 if (user_buf != NULL)
11222 {
11223 user_ptr->user_name = mystrdup (user_buf);
11224 }
11225 else
11226 {
11227 user_ptr->user_name = mystrdup ("");
11228 }
11229
11230 user_ptr->user_len = user_len;
11231 }
11232 }
11233
11234 if (opts_type & OPTS_TYPE_HASH_COPY)
11235 {
11236 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11237
11238 hash_info_tmp->orighash = mystrdup (hash_buf);
11239 }
11240
11241 if (isSalted)
11242 {
11243 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11244 }
11245
11246 if (hash_mode == 3000)
11247 {
11248 if (hash_len == 32)
11249 {
11250 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11251
11252 if (parser_status < PARSER_GLOBAL_ZERO)
11253 {
11254 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11255
11256 continue;
11257 }
11258
11259 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11260
11261 hashes_cnt++;
11262
11263 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11264
11265 if (parser_status < PARSER_GLOBAL_ZERO)
11266 {
11267 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11268
11269 continue;
11270 }
11271
11272 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11273
11274 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);
11275
11276 hashes_cnt++;
11277
11278 // show / left
11279
11280 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);
11281 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);
11282 }
11283 else
11284 {
11285 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11286
11287 if (parser_status < PARSER_GLOBAL_ZERO)
11288 {
11289 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11290
11291 continue;
11292 }
11293
11294 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);
11295
11296 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11297 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11298
11299 hashes_cnt++;
11300 }
11301 }
11302 else
11303 {
11304 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11305
11306 if (parser_status < PARSER_GLOBAL_ZERO)
11307 {
11308 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11309
11310 continue;
11311 }
11312
11313 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);
11314
11315 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11316 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11317
11318 hashes_cnt++;
11319 }
11320 }
11321
11322 myfree (line_buf);
11323
11324 fclose (fp);
11325
11326 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11327
11328 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11329 }
11330 }
11331 else
11332 {
11333 if (isSalted)
11334 {
11335 hashes_buf[0].salt->salt_len = 8;
11336
11337 // special salt handling
11338
11339 switch (hash_mode)
11340 {
11341 case 1500: hashes_buf[0].salt->salt_len = 2;
11342 break;
11343 case 1731: hashes_buf[0].salt->salt_len = 4;
11344 break;
11345 case 2410: hashes_buf[0].salt->salt_len = 4;
11346 break;
11347 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11348 break;
11349 case 3100: hashes_buf[0].salt->salt_len = 1;
11350 break;
11351 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11352 break;
11353 case 5800: hashes_buf[0].salt->salt_len = 16;
11354 break;
11355 case 6800: hashes_buf[0].salt->salt_len = 32;
11356 break;
11357 case 8400: hashes_buf[0].salt->salt_len = 40;
11358 break;
11359 case 8800: hashes_buf[0].salt->salt_len = 16;
11360 break;
11361 case 8900: hashes_buf[0].salt->salt_len = 16;
11362 hashes_buf[0].salt->scrypt_N = 1024;
11363 hashes_buf[0].salt->scrypt_r = 1;
11364 hashes_buf[0].salt->scrypt_p = 1;
11365 break;
11366 case 9100: hashes_buf[0].salt->salt_len = 16;
11367 break;
11368 case 9300: hashes_buf[0].salt->salt_len = 14;
11369 hashes_buf[0].salt->scrypt_N = 16384;
11370 hashes_buf[0].salt->scrypt_r = 1;
11371 hashes_buf[0].salt->scrypt_p = 1;
11372 break;
11373 case 9400: hashes_buf[0].salt->salt_len = 16;
11374 break;
11375 case 9500: hashes_buf[0].salt->salt_len = 16;
11376 break;
11377 case 9600: hashes_buf[0].salt->salt_len = 16;
11378 break;
11379 case 9700: hashes_buf[0].salt->salt_len = 16;
11380 break;
11381 case 9710: hashes_buf[0].salt->salt_len = 16;
11382 break;
11383 case 9720: hashes_buf[0].salt->salt_len = 16;
11384 break;
11385 case 9800: hashes_buf[0].salt->salt_len = 16;
11386 break;
11387 case 9810: hashes_buf[0].salt->salt_len = 16;
11388 break;
11389 case 9820: hashes_buf[0].salt->salt_len = 16;
11390 break;
11391 case 10300: hashes_buf[0].salt->salt_len = 12;
11392 break;
11393 case 11500: hashes_buf[0].salt->salt_len = 4;
11394 break;
11395 case 11600: hashes_buf[0].salt->salt_len = 4;
11396 break;
11397 case 12400: hashes_buf[0].salt->salt_len = 4;
11398 break;
11399 case 12500: hashes_buf[0].salt->salt_len = 8;
11400 break;
11401 case 12600: hashes_buf[0].salt->salt_len = 64;
11402 break;
11403 }
11404
11405 // special esalt handling
11406
11407 switch (hash_mode)
11408 {
11409 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11410 break;
11411 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11412 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11413 break;
11414 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11415 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11416 break;
11417 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11418 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11419 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11420 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11421 break;
11422 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11423 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11424 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11425 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11426 break;
11427 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11428 break;
11429 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11430 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11431 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11432 break;
11433 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11434 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11435 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11436 break;
11437 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11438 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11439 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11440 break;
11441 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11442 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11443 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11444 break;
11445 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11446 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11447 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11448 break;
11449 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11450 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11451 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11452 break;
11453 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11454 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11455 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11456 break;
11457 }
11458 }
11459
11460 // set hashfile
11461
11462 switch (hash_mode)
11463 {
11464 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11465 break;
11466 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11467 break;
11468 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11469 break;
11470 case 6211: data.hashfile = mystrdup ("hashcat.tc");
11471 break;
11472 case 6212: data.hashfile = mystrdup ("hashcat.tc");
11473 break;
11474 case 6213: data.hashfile = mystrdup ("hashcat.tc");
11475 break;
11476 case 6221: data.hashfile = mystrdup ("hashcat.tc");
11477 break;
11478 case 6222: data.hashfile = mystrdup ("hashcat.tc");
11479 break;
11480 case 6223: data.hashfile = mystrdup ("hashcat.tc");
11481 break;
11482 case 6231: data.hashfile = mystrdup ("hashcat.tc");
11483 break;
11484 case 6232: data.hashfile = mystrdup ("hashcat.tc");
11485 break;
11486 case 6233: data.hashfile = mystrdup ("hashcat.tc");
11487 break;
11488 case 6241: data.hashfile = mystrdup ("hashcat.tc");
11489 break;
11490 case 6242: data.hashfile = mystrdup ("hashcat.tc");
11491 break;
11492 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11493 break;
11494 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11495 break;
11496 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11497 break;
11498 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11499 break;
11500 }
11501
11502 // set default iterations
11503
11504 switch (hash_mode)
11505 {
11506 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11507 break;
11508 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11509 break;
11510 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11511 break;
11512 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11513 break;
11514 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11515 break;
11516 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11517 break;
11518 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11519 break;
11520 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11521 break;
11522 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11523 break;
11524 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11525 break;
11526 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11527 break;
11528 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11529 break;
11530 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11531 break;
11532 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11533 break;
11534 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11535 break;
11536 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11537 break;
11538 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11539 break;
11540 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11541 break;
11542 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11543 break;
11544 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11545 break;
11546 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11547 break;
11548 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11549 break;
11550 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11551 break;
11552 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11553 break;
11554 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11555 break;
11556 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11557 break;
11558 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11559 break;
11560 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11561 break;
11562 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11563 break;
11564 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11565 break;
11566 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11567 break;
11568 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11569 break;
11570 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11571 break;
11572 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11573 break;
11574 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11575 break;
11576 case 8900: hashes_buf[0].salt->salt_iter = 1;
11577 break;
11578 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11579 break;
11580 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11581 break;
11582 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11583 break;
11584 case 9300: hashes_buf[0].salt->salt_iter = 1;
11585 break;
11586 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11587 break;
11588 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11589 break;
11590 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11591 break;
11592 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11593 break;
11594 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11595 break;
11596 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11597 break;
11598 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11599 break;
11600 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11601 break;
11602 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11603 break;
11604 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11605 break;
11606 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11607 break;
11608 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11609 break;
11610 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11611 break;
11612 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11613 break;
11614 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11615 break;
11616 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11617 break;
11618 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11619 break;
11620 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11621 break;
11622 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11623 break;
11624 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11625 break;
11626 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11627 break;
11628 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
11629 break;
11630 }
11631
11632 hashes_cnt = 1;
11633 }
11634
11635 if (show == 1 || left == 1)
11636 {
11637 for (uint i = 0; i < pot_cnt; i++)
11638 {
11639 pot_t *pot_ptr = &pot[i];
11640
11641 hash_t *hashes_buf = &pot_ptr->hash;
11642
11643 local_free (hashes_buf->digest);
11644
11645 if (isSalted)
11646 {
11647 local_free (hashes_buf->salt);
11648 }
11649 }
11650
11651 local_free (pot);
11652
11653 if (data.quiet == 0) log_info_nn ("");
11654
11655 return (0);
11656 }
11657
11658 if (keyspace == 0)
11659 {
11660 if (hashes_cnt == 0)
11661 {
11662 log_error ("ERROR: No hashes loaded");
11663
11664 return (-1);
11665 }
11666 }
11667
11668 /**
11669 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11670 */
11671
11672 if (data.outfile != NULL)
11673 {
11674 if (data.hashfile != NULL)
11675 {
11676 #ifdef _POSIX
11677 struct stat tmpstat_outfile;
11678 struct stat tmpstat_hashfile;
11679 #endif
11680
11681 #ifdef _WIN
11682 struct stat64 tmpstat_outfile;
11683 struct stat64 tmpstat_hashfile;
11684 #endif
11685
11686 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11687
11688 if (tmp_outfile_fp)
11689 {
11690 #ifdef _POSIX
11691 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11692 #endif
11693
11694 #ifdef _WIN
11695 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11696 #endif
11697
11698 fclose (tmp_outfile_fp);
11699 }
11700
11701 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11702
11703 if (tmp_hashfile_fp)
11704 {
11705 #ifdef _POSIX
11706 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11707 #endif
11708
11709 #ifdef _WIN
11710 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11711 #endif
11712
11713 fclose (tmp_hashfile_fp);
11714 }
11715
11716 if (tmp_outfile_fp && tmp_outfile_fp)
11717 {
11718 tmpstat_outfile.st_mode = 0;
11719 tmpstat_outfile.st_nlink = 0;
11720 tmpstat_outfile.st_uid = 0;
11721 tmpstat_outfile.st_gid = 0;
11722 tmpstat_outfile.st_rdev = 0;
11723 tmpstat_outfile.st_atime = 0;
11724
11725 tmpstat_hashfile.st_mode = 0;
11726 tmpstat_hashfile.st_nlink = 0;
11727 tmpstat_hashfile.st_uid = 0;
11728 tmpstat_hashfile.st_gid = 0;
11729 tmpstat_hashfile.st_rdev = 0;
11730 tmpstat_hashfile.st_atime = 0;
11731
11732 #ifdef _POSIX
11733 tmpstat_outfile.st_blksize = 0;
11734 tmpstat_outfile.st_blocks = 0;
11735
11736 tmpstat_hashfile.st_blksize = 0;
11737 tmpstat_hashfile.st_blocks = 0;
11738 #endif
11739
11740 #ifdef _POSIX
11741 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11742 {
11743 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11744
11745 return (-1);
11746 }
11747 #endif
11748
11749 #ifdef _WIN
11750 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11751 {
11752 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11753
11754 return (-1);
11755 }
11756 #endif
11757 }
11758 }
11759 }
11760
11761 /**
11762 * Remove duplicates
11763 */
11764
11765 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11766
11767 if (isSalted)
11768 {
11769 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11770 }
11771 else
11772 {
11773 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11774 }
11775
11776 uint hashes_cnt_orig = hashes_cnt;
11777
11778 hashes_cnt = 1;
11779
11780 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11781 {
11782 if (isSalted)
11783 {
11784 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11785 {
11786 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11787 }
11788 }
11789 else
11790 {
11791 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11792 }
11793
11794 if (hashes_pos > hashes_cnt)
11795 {
11796 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11797 }
11798
11799 hashes_cnt++;
11800 }
11801
11802 /**
11803 * Potfile removes
11804 */
11805
11806 uint potfile_remove_cracks = 0;
11807
11808 if (potfile_disable == 0)
11809 {
11810 hash_t hash_buf;
11811
11812 hash_buf.digest = mymalloc (dgst_size);
11813 hash_buf.salt = NULL;
11814 hash_buf.esalt = NULL;
11815 hash_buf.hash_info = NULL;
11816 hash_buf.cracked = 0;
11817
11818 if (isSalted)
11819 {
11820 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11821 }
11822
11823 if (esalt_size)
11824 {
11825 hash_buf.esalt = mymalloc (esalt_size);
11826 }
11827
11828 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11829
11830 // no solution for these special hash types (for instane because they use hashfile in output etc)
11831 if ((hash_mode != 5200) &&
11832 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11833 (hash_mode != 9000))
11834 {
11835 FILE *fp = fopen (potfile, "rb");
11836
11837 if (fp != NULL)
11838 {
11839 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11840
11841 // to be safe work with a copy (because of line_len loop, i etc)
11842 // moved up here because it's easier to handle continue case
11843 // it's just 64kb
11844
11845 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
11846
11847 while (!feof (fp))
11848 {
11849 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
11850
11851 if (ptr == NULL) break;
11852
11853 int line_len = strlen (line_buf);
11854
11855 if (line_len == 0) continue;
11856
11857 int iter = MAX_CUT_TRIES;
11858
11859 for (int i = line_len - 1; i && iter; i--, line_len--)
11860 {
11861 if (line_buf[i] != ':') continue;
11862
11863 if (isSalted)
11864 {
11865 memset (hash_buf.salt, 0, sizeof (salt_t));
11866 }
11867
11868 hash_t *found = NULL;
11869
11870 if (hash_mode == 6800)
11871 {
11872 if (i < 64) // 64 = 16 * uint in salt_buf[]
11873 {
11874 // manipulate salt_buf
11875 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11876
11877 hash_buf.salt->salt_len = i;
11878
11879 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11880 }
11881 }
11882 else if (hash_mode == 2500)
11883 {
11884 if (i < 64) // 64 = 16 * uint in salt_buf[]
11885 {
11886 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11887 // manipulate salt_buf
11888
11889 memcpy (line_buf_cpy, line_buf, i);
11890
11891 char *mac2_pos = strrchr (line_buf_cpy, ':');
11892
11893 if (mac2_pos == NULL) continue;
11894
11895 mac2_pos[0] = 0;
11896 mac2_pos++;
11897
11898 if (strlen (mac2_pos) != 12) continue;
11899
11900 char *mac1_pos = strrchr (line_buf_cpy, ':');
11901
11902 if (mac1_pos == NULL) continue;
11903
11904 mac1_pos[0] = 0;
11905 mac1_pos++;
11906
11907 if (strlen (mac1_pos) != 12) continue;
11908
11909 uint essid_length = mac1_pos - line_buf_cpy - 1;
11910
11911 // here we need the ESSID
11912 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11913
11914 hash_buf.salt->salt_len = essid_length;
11915
11916 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11917
11918 if (found)
11919 {
11920 wpa_t *wpa = (wpa_t *) found->esalt;
11921
11922 uint pke[25] = { 0 };
11923
11924 char *pke_ptr = (char *) pke;
11925
11926 for (uint i = 0; i < 25; i++)
11927 {
11928 pke[i] = byte_swap_32 (wpa->pke[i]);
11929 }
11930
11931 u8 mac1[6] = { 0 };
11932 u8 mac2[6] = { 0 };
11933
11934 memcpy (mac1, pke_ptr + 23, 6);
11935 memcpy (mac2, pke_ptr + 29, 6);
11936
11937 // compare hex string(s) vs binary MAC address(es)
11938
11939 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11940 {
11941 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
11942 {
11943 found = NULL;
11944 break;
11945 }
11946 }
11947
11948 // early skip ;)
11949 if (!found) continue;
11950
11951 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11952 {
11953 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
11954 {
11955 found = NULL;
11956 break;
11957 }
11958 }
11959 }
11960 }
11961 }
11962 else
11963 {
11964 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
11965
11966 if (parser_status == PARSER_OK)
11967 {
11968 if (isSalted)
11969 {
11970 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11971 }
11972 else
11973 {
11974 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11975 }
11976 }
11977 }
11978
11979 if (found == NULL) continue;
11980
11981 if (!found->cracked) potfile_remove_cracks++;
11982
11983 found->cracked = 1;
11984
11985 if (found) break;
11986
11987 iter--;
11988 }
11989 }
11990
11991 myfree (line_buf_cpy);
11992
11993 myfree (line_buf);
11994
11995 fclose (fp);
11996 }
11997 }
11998
11999 if (esalt_size)
12000 {
12001 local_free (hash_buf.esalt);
12002 }
12003
12004 if (isSalted)
12005 {
12006 local_free (hash_buf.salt);
12007 }
12008
12009 local_free (hash_buf.digest);
12010 }
12011
12012 /**
12013 * Now generate all the buffers required for later
12014 */
12015
12016 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12017
12018 salt_t *salts_buf_new = NULL;
12019 void *esalts_buf_new = NULL;
12020
12021 if (isSalted)
12022 {
12023 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12024
12025 if (esalt_size)
12026 {
12027 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12028 }
12029 }
12030 else
12031 {
12032 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12033 }
12034
12035 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12036
12037 uint digests_cnt = hashes_cnt;
12038 uint digests_done = 0;
12039
12040 uint size_digests = digests_cnt * dgst_size;
12041 uint size_shown = digests_cnt * sizeof (uint);
12042
12043 uint *digests_shown = (uint *) mymalloc (size_shown);
12044 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12045
12046 uint salts_cnt = 0;
12047 uint salts_done = 0;
12048
12049 hashinfo_t **hash_info = NULL;
12050
12051 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12052 {
12053 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12054
12055 if (username && (remove || show))
12056 {
12057 uint user_pos;
12058
12059 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12060 {
12061 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12062
12063 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12064 }
12065 }
12066 }
12067
12068 uint *salts_shown = (uint *) mymalloc (size_shown);
12069
12070 salt_t *salt_buf;
12071
12072 {
12073 // copied from inner loop
12074
12075 salt_buf = &salts_buf_new[salts_cnt];
12076
12077 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12078
12079 if (esalt_size)
12080 {
12081 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12082 }
12083
12084 salt_buf->digests_cnt = 0;
12085 salt_buf->digests_done = 0;
12086 salt_buf->digests_offset = 0;
12087
12088 salts_cnt++;
12089 }
12090
12091 if (hashes_buf[0].cracked == 1)
12092 {
12093 digests_shown[0] = 1;
12094
12095 digests_done++;
12096
12097 salt_buf->digests_done++;
12098 }
12099
12100 salt_buf->digests_cnt++;
12101
12102 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12103
12104 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12105 {
12106 hash_info[0] = hashes_buf[0].hash_info;
12107 }
12108
12109 // copy from inner loop
12110
12111 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12112 {
12113 if (isSalted)
12114 {
12115 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12116 {
12117 salt_buf = &salts_buf_new[salts_cnt];
12118
12119 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12120
12121 if (esalt_size)
12122 {
12123 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12124 }
12125
12126 salt_buf->digests_cnt = 0;
12127 salt_buf->digests_done = 0;
12128 salt_buf->digests_offset = hashes_pos;
12129
12130 salts_cnt++;
12131 }
12132 }
12133
12134 if (hashes_buf[hashes_pos].cracked == 1)
12135 {
12136 digests_shown[hashes_pos] = 1;
12137
12138 digests_done++;
12139
12140 salt_buf->digests_done++;
12141 }
12142
12143 salt_buf->digests_cnt++;
12144
12145 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12146
12147 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12148 {
12149 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12150 }
12151 }
12152
12153 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12154 {
12155 salt_t *salt_buf = &salts_buf_new[salt_pos];
12156
12157 if (salt_buf->digests_done == salt_buf->digests_cnt)
12158 {
12159 salts_shown[salt_pos] = 1;
12160
12161 salts_done++;
12162 }
12163
12164 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12165 }
12166
12167 local_free (digests_buf);
12168 local_free (salts_buf);
12169 local_free (esalts_buf);
12170
12171 digests_buf = digests_buf_new;
12172 salts_buf = salts_buf_new;
12173 esalts_buf = esalts_buf_new;
12174
12175 local_free (hashes_buf);
12176
12177 /**
12178 * special modification not set from parser
12179 */
12180
12181 switch (hash_mode)
12182 {
12183 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12184 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12185 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12186 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12187 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12188 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12189 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12190 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12191 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12192 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12193 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12194 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12195 }
12196
12197 if (truecrypt_keyfiles)
12198 {
12199 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12200
12201 char *keyfiles = strdup (truecrypt_keyfiles);
12202
12203 char *keyfile = strtok (keyfiles, ",");
12204
12205 do
12206 {
12207 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12208
12209 } while ((keyfile = strtok (NULL, ",")) != NULL);
12210
12211 free (keyfiles);
12212 }
12213
12214 data.digests_cnt = digests_cnt;
12215 data.digests_done = digests_done;
12216 data.digests_buf = digests_buf;
12217 data.digests_shown = digests_shown;
12218 data.digests_shown_tmp = digests_shown_tmp;
12219
12220 data.salts_cnt = salts_cnt;
12221 data.salts_done = salts_done;
12222 data.salts_buf = salts_buf;
12223 data.salts_shown = salts_shown;
12224
12225 data.esalts_buf = esalts_buf;
12226 data.hash_info = hash_info;
12227
12228 /**
12229 * Automatic Optimizers
12230 */
12231
12232 if (salts_cnt == 1)
12233 opti_type |= OPTI_TYPE_SINGLE_SALT;
12234
12235 if (digests_cnt == 1)
12236 opti_type |= OPTI_TYPE_SINGLE_HASH;
12237
12238 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12239 opti_type |= OPTI_TYPE_NOT_ITERATED;
12240
12241 if (attack_mode == ATTACK_MODE_BF)
12242 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12243
12244 data.opti_type = opti_type;
12245
12246 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12247 {
12248 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12249 {
12250 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12251 {
12252 if (opts_type & OPTS_TYPE_ST_ADD80)
12253 {
12254 opts_type &= ~OPTS_TYPE_ST_ADD80;
12255 opts_type |= OPTS_TYPE_PT_ADD80;
12256 }
12257
12258 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12259 {
12260 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12261 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12262 }
12263
12264 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12265 {
12266 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12267 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12268 }
12269 }
12270 }
12271 }
12272
12273 /**
12274 * Some algorithm, like descrypt, can benefit from JIT compilation
12275 */
12276
12277 int force_jit_compilation = -1;
12278
12279 if (hash_mode == 8900)
12280 {
12281 force_jit_compilation = 8900;
12282 }
12283 else if (hash_mode == 9300)
12284 {
12285 force_jit_compilation = 8900;
12286 }
12287 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12288 {
12289 force_jit_compilation = 1500;
12290 }
12291
12292 /**
12293 * generate bitmap tables
12294 */
12295
12296 const uint bitmap_shift1 = 5;
12297 const uint bitmap_shift2 = 13;
12298
12299 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12300
12301 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12302 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12303 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12304 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12305 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12306 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12307 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12308 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12309
12310 uint bitmap_bits;
12311 uint bitmap_nums;
12312 uint bitmap_mask;
12313 uint bitmap_size;
12314
12315 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12316 {
12317 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12318
12319 bitmap_nums = 1 << bitmap_bits;
12320
12321 bitmap_mask = bitmap_nums - 1;
12322
12323 bitmap_size = bitmap_nums * sizeof (uint);
12324
12325 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12326
12327 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;
12328 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;
12329
12330 break;
12331 }
12332
12333 bitmap_nums = 1 << bitmap_bits;
12334
12335 bitmap_mask = bitmap_nums - 1;
12336
12337 bitmap_size = bitmap_nums * sizeof (uint);
12338
12339 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);
12340 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);
12341
12342 /**
12343 * prepare quick rule
12344 */
12345
12346 data.rule_buf_l = rule_buf_l;
12347 data.rule_buf_r = rule_buf_r;
12348
12349 int rule_len_l = (int) strlen (rule_buf_l);
12350 int rule_len_r = (int) strlen (rule_buf_r);
12351
12352 data.rule_len_l = rule_len_l;
12353 data.rule_len_r = rule_len_r;
12354
12355 /**
12356 * load rules
12357 */
12358
12359 uint *all_kernel_rules_cnt = NULL;
12360
12361 kernel_rule_t **all_kernel_rules_buf = NULL;
12362
12363 if (rp_files_cnt)
12364 {
12365 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12366
12367 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12368 }
12369
12370 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
12371
12372 int rule_len = 0;
12373
12374 for (uint i = 0; i < rp_files_cnt; i++)
12375 {
12376 uint kernel_rules_avail = 0;
12377
12378 uint kernel_rules_cnt = 0;
12379
12380 kernel_rule_t *kernel_rules_buf = NULL;
12381
12382 char *rp_file = rp_files[i];
12383
12384 char in[BLOCK_SIZE] = { 0 };
12385 char out[BLOCK_SIZE] = { 0 };
12386
12387 FILE *fp = NULL;
12388
12389 uint rule_line = 0;
12390
12391 if ((fp = fopen (rp_file, "rb")) == NULL)
12392 {
12393 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12394
12395 return (-1);
12396 }
12397
12398 while (!feof (fp))
12399 {
12400 memset (rule_buf, 0, HCBUFSIZ);
12401
12402 rule_len = fgetl (fp, rule_buf);
12403
12404 rule_line++;
12405
12406 if (rule_len == 0) continue;
12407
12408 if (rule_buf[0] == '#') continue;
12409
12410 if (kernel_rules_avail == kernel_rules_cnt)
12411 {
12412 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12413
12414 kernel_rules_avail += INCR_RULES;
12415 }
12416
12417 memset (in, 0, BLOCK_SIZE);
12418 memset (out, 0, BLOCK_SIZE);
12419
12420 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12421
12422 if (result == -1)
12423 {
12424 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12425
12426 continue;
12427 }
12428
12429 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12430 {
12431 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12432
12433 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12434
12435 continue;
12436 }
12437
12438 /* its so slow
12439 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12440 {
12441 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12442
12443 continue;
12444 }
12445 */
12446
12447 kernel_rules_cnt++;
12448 }
12449
12450 fclose (fp);
12451
12452 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12453
12454 all_kernel_rules_buf[i] = kernel_rules_buf;
12455 }
12456
12457 /**
12458 * merge rules or automatic rule generator
12459 */
12460
12461 uint kernel_rules_cnt = 0;
12462
12463 kernel_rule_t *kernel_rules_buf = NULL;
12464
12465 if (attack_mode == ATTACK_MODE_STRAIGHT)
12466 {
12467 if (rp_files_cnt)
12468 {
12469 kernel_rules_cnt = 1;
12470
12471 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12472
12473 repeats[0] = kernel_rules_cnt;
12474
12475 for (uint i = 0; i < rp_files_cnt; i++)
12476 {
12477 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12478
12479 repeats[i + 1] = kernel_rules_cnt;
12480 }
12481
12482 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12483
12484 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12485
12486 for (uint i = 0; i < kernel_rules_cnt; i++)
12487 {
12488 uint out_pos = 0;
12489
12490 kernel_rule_t *out = &kernel_rules_buf[i];
12491
12492 for (uint j = 0; j < rp_files_cnt; j++)
12493 {
12494 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12495 uint in_pos;
12496
12497 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12498
12499 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12500 {
12501 if (out_pos == RULES_MAX - 1)
12502 {
12503 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12504
12505 break;
12506 }
12507
12508 out->cmds[out_pos] = in->cmds[in_pos];
12509 }
12510 }
12511 }
12512
12513 local_free (repeats);
12514 }
12515 else if (rp_gen)
12516 {
12517 uint kernel_rules_avail = 0;
12518
12519 while (kernel_rules_cnt < rp_gen)
12520 {
12521 if (kernel_rules_avail == kernel_rules_cnt)
12522 {
12523 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12524
12525 kernel_rules_avail += INCR_RULES;
12526 }
12527
12528 memset (rule_buf, 0, HCBUFSIZ);
12529
12530 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12531
12532 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12533
12534 kernel_rules_cnt++;
12535 }
12536 }
12537 }
12538
12539 myfree (rule_buf);
12540
12541 /**
12542 * generate NOP rules
12543 */
12544
12545 if (kernel_rules_cnt == 0)
12546 {
12547 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12548
12549 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12550
12551 kernel_rules_cnt++;
12552 }
12553
12554 data.kernel_rules_cnt = kernel_rules_cnt;
12555 data.kernel_rules_buf = kernel_rules_buf;
12556
12557 /**
12558 * OpenCL platforms: detect
12559 */
12560
12561 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
12562 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
12563
12564 cl_uint platforms_cnt = 0;
12565 cl_uint platform_devices_cnt = 0;
12566
12567 if (keyspace == 0)
12568 {
12569 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12570
12571 if (platforms_cnt == 0)
12572 {
12573 log_error ("ERROR: No OpenCL compatible platform found");
12574
12575 return (-1);
12576 }
12577
12578 if (opencl_platforms_filter != (uint) -1)
12579 {
12580 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
12581
12582 if (opencl_platforms_filter > platform_cnt_mask)
12583 {
12584 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
12585
12586 return (-1);
12587 }
12588 }
12589 }
12590
12591 /**
12592 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12593 */
12594
12595 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12596 {
12597 cl_platform_id platform = platforms[platform_id];
12598
12599 char platform_vendor[INFOSZ] = { 0 };
12600
12601 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12602
12603 #ifdef HAVE_HWMON
12604 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12605 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12606 {
12607 // make sure that we do not directly control the fan for NVidia
12608
12609 gpu_temp_retain = 0;
12610
12611 data.gpu_temp_retain = gpu_temp_retain;
12612 }
12613 #endif // HAVE_NVML || HAVE_NVAPI
12614 #endif
12615 }
12616
12617 /**
12618 * OpenCL devices: simply push all devices from all platforms into the same device array
12619 */
12620
12621 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12622
12623 data.devices_param = devices_param;
12624
12625 uint devices_cnt = 0;
12626
12627 uint devices_active = 0;
12628
12629 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12630 {
12631 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12632
12633 cl_platform_id platform = platforms[platform_id];
12634
12635 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12636
12637 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12638 {
12639 size_t param_value_size = 0;
12640
12641 const uint device_id = devices_cnt;
12642
12643 hc_device_param_t *device_param = &data.devices_param[device_id];
12644
12645 device_param->device = platform_devices[platform_devices_id];
12646
12647 device_param->device_id = device_id;
12648
12649 device_param->platform_devices_id = platform_devices_id;
12650
12651 // device_type
12652
12653 cl_device_type device_type;
12654
12655 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12656
12657 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12658
12659 device_param->device_type = device_type;
12660
12661 // vendor_id
12662
12663 cl_uint vendor_id = 0;
12664
12665 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR_ID, sizeof (vendor_id), &vendor_id, NULL);
12666
12667 device_param->vendor_id = vendor_id;
12668
12669 // device_name
12670
12671 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
12672
12673 char *device_name = (char *) mymalloc (param_value_size);
12674
12675 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
12676
12677 device_param->device_name = device_name;
12678
12679 // tuning db
12680
12681 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
12682
12683 // device_version
12684
12685 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
12686
12687 char *device_version = (char *) mymalloc (param_value_size);
12688
12689 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
12690
12691 device_param->device_version = device_version;
12692
12693 // device_opencl_version
12694
12695 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
12696
12697 char *device_opencl_version = (char *) mymalloc (param_value_size);
12698
12699 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
12700
12701 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
12702
12703 myfree (device_opencl_version);
12704
12705 if (strstr (device_version, "pocl"))
12706 {
12707 // pocl returns the real vendor_id in CL_DEVICE_VENDOR_ID which causes many problems because of hms and missing amd_bfe () etc
12708 // we need to overwrite vendor_id to avoid this. maybe open pocl issue?
12709
12710 cl_uint vendor_id = VENDOR_ID_GENERIC;
12711
12712 device_param->vendor_id = vendor_id;
12713 }
12714
12715 // vector_width
12716
12717 cl_uint vector_width;
12718
12719 if (opencl_vector_width_chgd == 0)
12720 {
12721 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
12722 {
12723 if (opti_type & OPTI_TYPE_USES_BITS_64)
12724 {
12725 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
12726 }
12727 else
12728 {
12729 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12730 }
12731 }
12732 else
12733 {
12734 vector_width = (cl_uint) tuningdb_entry->vector_width;
12735 }
12736 }
12737 else
12738 {
12739 vector_width = opencl_vector_width;
12740 }
12741
12742 if (vector_width > 16) vector_width = 16;
12743
12744 device_param->vector_width = vector_width;
12745
12746 // max_compute_units
12747
12748 cl_uint device_processors;
12749
12750 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12751
12752 device_param->device_processors = device_processors;
12753
12754 // max_mem_alloc_size
12755
12756 cl_ulong device_maxmem_alloc;
12757
12758 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12759
12760 device_param->device_maxmem_alloc = device_maxmem_alloc;
12761
12762 // max_mem_alloc_size
12763
12764 cl_ulong device_global_mem;
12765
12766 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12767
12768 device_param->device_global_mem = device_global_mem;
12769
12770 // max_clock_frequency
12771
12772 cl_uint device_maxclock_frequency;
12773
12774 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12775
12776 device_param->device_maxclock_frequency = device_maxclock_frequency;
12777
12778 // skipped
12779
12780 const u32 skipped1 = ((devices_filter & (1 << device_id)) == 0);
12781 const u32 skipped2 = ((device_types_filter & (device_type)) == 0);
12782
12783 device_param->skipped = (skipped1 || skipped2);
12784
12785 // driver_version
12786 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
12787
12788 char *driver_version = (char *) mymalloc (param_value_size);
12789
12790 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
12791
12792 device_param->driver_version = driver_version;
12793
12794 // device_name_chksum
12795
12796 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12797
12798 #if __x86_64__
12799 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);
12800 #else
12801 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);
12802 #endif
12803
12804 uint device_name_digest[4] = { 0 };
12805
12806 md5_64 ((uint *) device_name_chksum, device_name_digest);
12807
12808 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
12809
12810 device_param->device_name_chksum = device_name_chksum;
12811
12812 // device_processor_cores
12813
12814 if (device_type & CL_DEVICE_TYPE_CPU)
12815 {
12816 cl_uint device_processor_cores = 1;
12817
12818 device_param->device_processor_cores = device_processor_cores;
12819 }
12820
12821 if (device_type & CL_DEVICE_TYPE_GPU)
12822 {
12823 if (vendor_id == VENDOR_ID_AMD)
12824 {
12825 cl_uint device_processor_cores = 0;
12826
12827 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12828
12829 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12830
12831 device_param->device_processor_cores = device_processor_cores;
12832 }
12833 else if (vendor_id == VENDOR_ID_NV)
12834 {
12835 cl_uint kernel_exec_timeout = 0;
12836
12837 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12838
12839 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12840
12841 device_param->kernel_exec_timeout = kernel_exec_timeout;
12842
12843 cl_uint device_processor_cores = 0;
12844
12845 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12846
12847 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12848
12849 device_param->device_processor_cores = device_processor_cores;
12850
12851 cl_uint sm_minor = 0;
12852 cl_uint sm_major = 0;
12853
12854 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12855 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12856
12857 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12858 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12859
12860 device_param->sm_minor = sm_minor;
12861 device_param->sm_major = sm_major;
12862 }
12863 else
12864 {
12865 cl_uint device_processor_cores = 1;
12866
12867 device_param->device_processor_cores = device_processor_cores;
12868 }
12869 }
12870
12871 // display results
12872
12873 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12874 {
12875 if (device_param->skipped == 0)
12876 {
12877 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12878 device_id + 1,
12879 device_name,
12880 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
12881 (unsigned int) (device_global_mem / 1024 / 1024),
12882 (unsigned int) (device_maxclock_frequency),
12883 (unsigned int) device_processors);
12884 }
12885 else
12886 {
12887 log_info ("Device #%u: %s, skipped",
12888 device_id + 1,
12889 device_name);
12890 }
12891 }
12892
12893 // common driver check
12894
12895 if (device_param->skipped == 0)
12896 {
12897 if (strstr (device_version, "pocl"))
12898 {
12899 if (force == 0)
12900 {
12901 log_info ("");
12902 log_info ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
12903 log_info ("You are STRONGLY encouraged not to use it");
12904 log_info ("You can use --force to override this but do not post error reports if you do so");
12905 log_info ("");
12906
12907 return (-1);
12908 }
12909 }
12910
12911 if (device_type & CL_DEVICE_TYPE_GPU)
12912 {
12913 if (vendor_id == VENDOR_ID_NV)
12914 {
12915 if (device_param->kernel_exec_timeout != 0)
12916 {
12917 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);
12918 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12919 }
12920 }
12921 else if (vendor_id == VENDOR_ID_AMD)
12922 {
12923 int catalyst_check = (force == 1) ? 0 : 1;
12924
12925 int catalyst_warn = 0;
12926
12927 int catalyst_broken = 0;
12928
12929 if (catalyst_check == 1)
12930 {
12931 catalyst_warn = 1;
12932
12933 // v14.9 and higher
12934 if (atoi (device_param->driver_version) >= 1573)
12935 {
12936 catalyst_warn = 0;
12937 }
12938
12939 catalyst_check = 0;
12940 }
12941
12942 if (catalyst_broken == 1)
12943 {
12944 log_info ("");
12945 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
12946 log_info ("It will pass over cracked hashes and does not report them as cracked");
12947 log_info ("You are STRONGLY encouraged not to use it");
12948 log_info ("You can use --force to override this but do not post error reports if you do so");
12949 log_info ("");
12950
12951 return (-1);
12952 }
12953
12954 if (catalyst_warn == 1)
12955 {
12956 log_info ("");
12957 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
12958 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
12959 log_info ("See oclHashcat's homepage for official supported catalyst drivers");
12960 #ifdef _WIN
12961 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
12962 #endif
12963 log_info ("You can use --force to override this but do not post error reports if you do so");
12964 log_info ("");
12965
12966 return (-1);
12967 }
12968 }
12969 }
12970
12971 /**
12972 * kernel accel and loops tuning db adjustment
12973 */
12974
12975 device_param->kernel_accel_min = 1;
12976 device_param->kernel_accel_max = 1024;
12977
12978 device_param->kernel_loops_min = 1;
12979 device_param->kernel_loops_max = 1024;
12980
12981 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
12982
12983 if (tuningdb_entry)
12984 {
12985 u32 _kernel_accel = tuningdb_entry->kernel_accel;
12986 u32 _kernel_loops = tuningdb_entry->kernel_loops;
12987
12988 if (_kernel_accel)
12989 {
12990 device_param->kernel_accel_min = _kernel_accel;
12991 device_param->kernel_accel_max = _kernel_accel;
12992 }
12993
12994 if (_kernel_loops)
12995 {
12996 if (workload_profile == 1)
12997 {
12998 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
12999 }
13000 else if (workload_profile == 2)
13001 {
13002 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13003 }
13004
13005 device_param->kernel_loops_min = _kernel_loops;
13006 device_param->kernel_loops_max = _kernel_loops;
13007 }
13008 }
13009
13010 // commandline parameters overwrite tuningdb entries
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 device_param->kernel_loops_min = kernel_loops;
13021 device_param->kernel_loops_max = kernel_loops;
13022 }
13023
13024 /**
13025 * activate device
13026 */
13027
13028 devices_active++;
13029 }
13030
13031 // next please
13032
13033 devices_cnt++;
13034 }
13035 }
13036
13037 if (keyspace == 0 && devices_active == 0)
13038 {
13039 log_error ("ERROR: No devices found/left");
13040
13041 return (-1);
13042 }
13043
13044 // 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)
13045
13046 if (devices_filter != (uint) -1)
13047 {
13048 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
13049
13050 if (devices_filter > devices_cnt_mask)
13051 {
13052 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
13053
13054 return (-1);
13055 }
13056 }
13057
13058 data.devices_cnt = devices_cnt;
13059
13060 data.devices_active = devices_active;
13061
13062 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13063 {
13064 log_info ("");
13065 }
13066
13067 /**
13068 * HM devices: init
13069 */
13070
13071 #ifdef HAVE_HWMON
13072 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13073 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13074 #endif
13075
13076 #ifdef HAVE_ADL
13077 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13078 #endif
13079
13080 if (gpu_temp_disable == 0)
13081 {
13082 #if defined(WIN) && defined(HAVE_NVAPI)
13083 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13084
13085 if (nvapi_init (nvapi) == 0)
13086 data.hm_nv = nvapi;
13087
13088 if (data.hm_nv)
13089 {
13090 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13091 {
13092 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13093
13094 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13095
13096 int tmp_out = 0;
13097
13098 for (int i = 0; i < tmp_in; i++)
13099 {
13100 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13101 }
13102
13103 for (int i = 0; i < tmp_out; i++)
13104 {
13105 NV_GPU_COOLER_SETTINGS pCoolerSettings;
13106
13107 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
13108
13109 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;
13110 }
13111 }
13112 }
13113 #endif // WIN && HAVE_NVAPI
13114
13115 #if defined(LINUX) && defined(HAVE_NVML)
13116 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13117
13118 if (nvml_init (nvml) == 0)
13119 data.hm_nv = nvml;
13120
13121 if (data.hm_nv)
13122 {
13123 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13124 {
13125 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13126
13127 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13128
13129 int tmp_out = 0;
13130
13131 for (int i = 0; i < tmp_in; i++)
13132 {
13133 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13134 }
13135
13136 for (int i = 0; i < tmp_out; i++)
13137 {
13138 unsigned int speed;
13139
13140 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;
13141 }
13142 }
13143 }
13144 #endif // LINUX && HAVE_NVML
13145
13146 data.hm_amd = NULL;
13147
13148 #ifdef HAVE_ADL
13149 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13150
13151 if (adl_init (adl) == 0)
13152 data.hm_amd = adl;
13153
13154 if (data.hm_amd)
13155 {
13156 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13157 {
13158 // total number of adapters
13159
13160 int hm_adapters_num;
13161
13162 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13163
13164 // adapter info
13165
13166 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13167
13168 if (lpAdapterInfo == NULL) return (-1);
13169
13170 // get a list (of ids of) valid/usable adapters
13171
13172 int num_adl_adapters = 0;
13173
13174 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13175
13176 if (num_adl_adapters > 0)
13177 {
13178 hc_thread_mutex_lock (mux_adl);
13179
13180 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13181
13182 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13183
13184 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13185 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13186
13187 hc_thread_mutex_unlock (mux_adl);
13188 }
13189
13190 myfree (valid_adl_device_list);
13191 myfree (lpAdapterInfo);
13192 }
13193 }
13194 #endif // HAVE_ADL
13195
13196 if (data.hm_amd == NULL && data.hm_nv == NULL)
13197 {
13198 gpu_temp_disable = 1;
13199 }
13200 }
13201
13202 /**
13203 * OpenCL devices: allocate buffer for device specific information
13204 */
13205
13206 #ifdef HAVE_HWMON
13207 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13208
13209 #ifdef HAVE_ADL
13210 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13211
13212 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13213 #endif // ADL
13214 #endif
13215
13216 /**
13217 * enable custom signal handler(s)
13218 */
13219
13220 if (benchmark == 0)
13221 {
13222 hc_signal (sigHandler_default);
13223 }
13224 else
13225 {
13226 hc_signal (sigHandler_benchmark);
13227 }
13228
13229 /**
13230 * User-defined GPU temp handling
13231 */
13232
13233 #ifdef HAVE_HWMON
13234 if (gpu_temp_disable == 1)
13235 {
13236 gpu_temp_abort = 0;
13237 gpu_temp_retain = 0;
13238 }
13239
13240 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13241 {
13242 if (gpu_temp_abort < gpu_temp_retain)
13243 {
13244 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13245
13246 return (-1);
13247 }
13248 }
13249
13250 data.gpu_temp_disable = gpu_temp_disable;
13251 data.gpu_temp_abort = gpu_temp_abort;
13252 data.gpu_temp_retain = gpu_temp_retain;
13253 #endif
13254
13255 /**
13256 * inform the user
13257 */
13258
13259 if (data.quiet == 0)
13260 {
13261 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13262
13263 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);
13264
13265 if (attack_mode == ATTACK_MODE_STRAIGHT)
13266 {
13267 log_info ("Rules: %u", kernel_rules_cnt);
13268 }
13269
13270 if (opti_type)
13271 {
13272 log_info ("Applicable Optimizers:");
13273
13274 for (uint i = 0; i < 32; i++)
13275 {
13276 const uint opti_bit = 1u << i;
13277
13278 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13279 }
13280 }
13281
13282 /**
13283 * Watchdog and Temperature balance
13284 */
13285
13286 #ifdef HAVE_HWMON
13287 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13288 {
13289 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13290 }
13291
13292 if (gpu_temp_abort == 0)
13293 {
13294 log_info ("Watchdog: Temperature abort trigger disabled");
13295 }
13296 else
13297 {
13298 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13299 }
13300
13301 if (gpu_temp_retain == 0)
13302 {
13303 log_info ("Watchdog: Temperature retain trigger disabled");
13304 }
13305 else
13306 {
13307 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13308 }
13309 #endif
13310 }
13311
13312 if (data.quiet == 0) log_info ("");
13313
13314 /**
13315 * HM devices: copy
13316 */
13317
13318 if (gpu_temp_disable == 0)
13319 {
13320 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13321 {
13322 hc_device_param_t *device_param = &data.devices_param[device_id];
13323
13324 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13325
13326 if (device_param->skipped) continue;
13327
13328 const uint platform_devices_id = device_param->platform_devices_id;
13329
13330 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13331 if (device_param->vendor_id == VENDOR_ID_NV)
13332 {
13333 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13334 }
13335 #endif
13336
13337 #ifdef HAVE_ADL
13338 if (device_param->vendor_id == VENDOR_ID_AMD)
13339 {
13340 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13341 }
13342 #endif
13343 }
13344 }
13345
13346 /*
13347 * Temporary fix:
13348 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13349 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13350 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13351 * Driver / ADL bug?
13352 */
13353
13354 #ifdef HAVE_ADL
13355 if (powertune_enable == 1)
13356 {
13357 hc_thread_mutex_lock (mux_adl);
13358
13359 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13360 {
13361 hc_device_param_t *device_param = &data.devices_param[device_id];
13362
13363 if (device_param->skipped) continue;
13364
13365 if (data.hm_device[device_id].od_version == 6)
13366 {
13367 // set powertune value only
13368
13369 int powertune_supported = 0;
13370
13371 int ADL_rc = 0;
13372
13373 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13374 {
13375 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13376
13377 return (-1);
13378 }
13379
13380 if (powertune_supported != 0)
13381 {
13382 // powertune set
13383 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13384
13385 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13386 {
13387 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13388
13389 return (-1);
13390 }
13391
13392 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13393 {
13394 log_error ("ERROR: Failed to set new ADL PowerControl values");
13395
13396 return (-1);
13397 }
13398 }
13399 }
13400 }
13401
13402 hc_thread_mutex_unlock (mux_adl);
13403 }
13404 #endif // HAVE_ADK
13405 #endif // HAVE_HWMON
13406
13407 #ifdef DEBUG
13408 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
13409 #endif
13410
13411 uint kernel_power_all = 0;
13412
13413 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13414 {
13415 /**
13416 * host buffer
13417 */
13418
13419 hc_device_param_t *device_param = &data.devices_param[device_id];
13420
13421 if (device_param->skipped) continue;
13422
13423 /**
13424 * device properties
13425 */
13426
13427 const char *device_name_chksum = device_param->device_name_chksum;
13428 const u32 device_processors = device_param->device_processors;
13429 const u32 device_processor_cores = device_param->device_processor_cores;
13430
13431 /**
13432 * create context for each device
13433 */
13434
13435 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
13436
13437 /**
13438 * create command-queue
13439 */
13440
13441 // not supported with NV
13442 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13443
13444 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
13445
13446 /**
13447 * create input buffers on device : calculate size of fixed memory buffers
13448 */
13449
13450 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13451 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13452
13453 device_param->size_root_css = size_root_css;
13454 device_param->size_markov_css = size_markov_css;
13455
13456 uint size_results = KERNEL_THREADS * sizeof (uint);
13457
13458 device_param->size_results = size_results;
13459
13460 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13461 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13462
13463 uint size_plains = digests_cnt * sizeof (plain_t);
13464 uint size_salts = salts_cnt * sizeof (salt_t);
13465 uint size_esalts = salts_cnt * esalt_size;
13466
13467 device_param->size_plains = size_plains;
13468 device_param->size_digests = size_digests;
13469 device_param->size_shown = size_shown;
13470 device_param->size_salts = size_salts;
13471
13472 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13473 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13474 uint size_tm = 32 * sizeof (bs_word_t);
13475
13476 // scryptV stuff
13477
13478 u64 size_scryptV = 1;
13479
13480 if ((hash_mode == 8900) || (hash_mode == 9300))
13481 {
13482 uint tmto_start = 0;
13483 uint tmto_stop = 10;
13484
13485 if (scrypt_tmto)
13486 {
13487 tmto_start = scrypt_tmto;
13488 }
13489 else
13490 {
13491 // in case the user did not specify the tmto manually
13492 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13493 // but set the lower end only in case the user has a device with too less memory
13494
13495 if (hash_mode == 8900)
13496 {
13497 if (device_param->vendor_id == VENDOR_ID_AMD)
13498 {
13499 tmto_start = 1;
13500 }
13501 else if (device_param->vendor_id == VENDOR_ID_NV)
13502 {
13503 tmto_start = 3;
13504 }
13505 }
13506 else if (hash_mode == 9300)
13507 {
13508 if (device_param->vendor_id == VENDOR_ID_AMD)
13509 {
13510 tmto_start = 3;
13511 }
13512 else if (device_param->vendor_id == VENDOR_ID_NV)
13513 {
13514 tmto_start = 5;
13515 }
13516 }
13517 }
13518
13519 if (quiet == 0) log_info ("");
13520
13521 uint shader_per_mp = 1;
13522
13523 if (device_param->vendor_id == VENDOR_ID_AMD)
13524 {
13525 shader_per_mp = 8;
13526 }
13527 else if (device_param->vendor_id == VENDOR_ID_NV)
13528 {
13529 shader_per_mp = 32;
13530 }
13531
13532 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13533 {
13534 // TODO: in theory the following calculation needs to be done per salt, not global
13535 // we assume all hashes have the same scrypt settings
13536
13537 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13538
13539 size_scryptV /= 1 << tmto;
13540
13541 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13542
13543 if (size_scryptV > device_param->device_maxmem_alloc)
13544 {
13545 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13546
13547 continue;
13548 }
13549
13550 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13551 {
13552 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13553 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13554 }
13555
13556 break;
13557 }
13558
13559 if (data.salts_buf[0].scrypt_phy == 0)
13560 {
13561 log_error ("ERROR: can't allocate enough device memory");
13562
13563 return -1;
13564 }
13565
13566 if (quiet == 0) log_info ("");
13567 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13568 }
13569
13570 /**
13571 * create input buffers on device : calculate size of dynamic size memory buffers
13572 */
13573
13574 uint kernel_threads = KERNEL_THREADS;
13575
13576 // some algorithms need a fixed kernel-threads count (mostly because of shared memory usage)
13577
13578 if (hash_mode == 3200) kernel_threads = 8;
13579 if (hash_mode == 9000) kernel_threads = 8;
13580
13581 /**
13582 * some algorithms need a fixed kernel-loops count
13583 */
13584
13585 if (hash_mode == 1500)
13586 {
13587 const u32 kernel_loops_fixed = 1024;
13588
13589 device_param->kernel_loops_min = kernel_loops_fixed;
13590 device_param->kernel_loops_max = kernel_loops_fixed;
13591 }
13592
13593 if (hash_mode == 3000)
13594 {
13595 const u32 kernel_loops_fixed = 1024;
13596
13597 device_param->kernel_loops_min = kernel_loops_fixed;
13598 device_param->kernel_loops_max = kernel_loops_fixed;
13599 }
13600
13601 if (hash_mode == 8900)
13602 {
13603 const u32 kernel_loops_fixed = 1;
13604
13605 device_param->kernel_loops_min = kernel_loops_fixed;
13606 device_param->kernel_loops_max = kernel_loops_fixed;
13607 }
13608
13609 if (hash_mode == 9300)
13610 {
13611 const u32 kernel_loops_fixed = 1;
13612
13613 device_param->kernel_loops_min = kernel_loops_fixed;
13614 device_param->kernel_loops_max = kernel_loops_fixed;
13615 }
13616
13617 if (hash_mode == 12500)
13618 {
13619 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
13620
13621 device_param->kernel_loops_min = kernel_loops_fixed;
13622 device_param->kernel_loops_max = kernel_loops_fixed;
13623 }
13624
13625 /**
13626 * some algorithms have a maximum kernel-loops count
13627 */
13628
13629 if (attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
13630 {
13631 if (data.salts_buf[0].salt_iter < device_param->kernel_loops_max)
13632 {
13633 device_param->kernel_loops_max = data.salts_buf[0].salt_iter;
13634 }
13635 }
13636
13637 /**
13638 * some algorithms need a special kernel-accel
13639 */
13640
13641 if (hash_mode == 8900)
13642 {
13643 device_param->kernel_accel_min = 1;
13644 device_param->kernel_accel_max = 64;
13645 }
13646
13647 if (hash_mode == 9300)
13648 {
13649 device_param->kernel_accel_min = 1;
13650 device_param->kernel_accel_max = 64;
13651 }
13652
13653 u32 kernel_accel_min = device_param->kernel_accel_min;
13654 u32 kernel_accel_max = device_param->kernel_accel_max;
13655
13656 // find out if we would request too much memory on memory blocks which are based on kernel_accel
13657
13658 uint size_pws = 4;
13659 uint size_tmps = 4;
13660 uint size_hooks = 4;
13661
13662 while (kernel_accel_max >= kernel_accel_min)
13663 {
13664 uint kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
13665
13666 // size_pws
13667
13668 size_pws = kernel_power_max * sizeof (pw_t);
13669
13670 // size_tmps
13671
13672 switch (hash_mode)
13673 {
13674 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
13675 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13676 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13677 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13678 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
13679 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
13680 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
13681 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
13682 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
13683 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
13684 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13685 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13686 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13687 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13688 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13689 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13690 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13691 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13692 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13693 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13694 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13695 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13696 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13697 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
13698 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
13699 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
13700 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
13701 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
13702 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13703 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13704 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
13705 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
13706 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13707 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
13708 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13709 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
13710 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
13711 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13712 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13713 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
13714 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
13715 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
13716 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13717 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
13718 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
13719 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
13720 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
13721 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13722 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
13723 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
13724 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
13725 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
13726 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13727 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
13728 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
13729 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
13730 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
13731 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
13732 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13733 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13734 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13735 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
13736 };
13737
13738 // size_hooks
13739
13740 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13741 {
13742 // none yet
13743 }
13744
13745 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
13746 // if not, decrease amplifier and try again
13747
13748 int skip = 0;
13749
13750 if (size_pws > device_param->device_maxmem_alloc) skip = 1;
13751 if (size_tmps > device_param->device_maxmem_alloc) skip = 1;
13752 if (size_hooks > device_param->device_maxmem_alloc) skip = 1;
13753
13754 if (( bitmap_size
13755 + bitmap_size
13756 + bitmap_size
13757 + bitmap_size
13758 + bitmap_size
13759 + bitmap_size
13760 + bitmap_size
13761 + bitmap_size
13762 + size_bfs
13763 + size_combs
13764 + size_digests
13765 + size_esalts
13766 + size_hooks
13767 + size_markov_css
13768 + size_plains
13769 + size_pws
13770 + size_results
13771 + size_root_css
13772 + size_rules
13773 + size_rules_c
13774 + size_salts
13775 + size_scryptV
13776 + size_shown
13777 + size_tm
13778 + size_tmps) > device_param->device_global_mem) skip = 1;
13779
13780 if (skip == 1)
13781 {
13782 kernel_accel_max--;
13783
13784 continue;
13785 }
13786
13787 break;
13788 }
13789
13790 /*
13791 if (kernel_accel_max == 0)
13792 {
13793 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
13794
13795 return -1;
13796 }
13797 */
13798
13799 device_param->kernel_accel_min = kernel_accel_min;
13800 device_param->kernel_accel_max = kernel_accel_max;
13801
13802 /*
13803 if (kernel_accel_max < kernel_accel)
13804 {
13805 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
13806
13807 device_param->kernel_accel = kernel_accel_max;
13808 }
13809 */
13810
13811 device_param->size_bfs = size_bfs;
13812 device_param->size_combs = size_combs;
13813 device_param->size_rules = size_rules;
13814 device_param->size_rules_c = size_rules_c;
13815 device_param->size_pws = size_pws;
13816 device_param->size_tmps = size_tmps;
13817 device_param->size_hooks = size_hooks;
13818
13819 // do not confuse kernel_accel_max with kernel_accel here
13820
13821 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
13822
13823 device_param->kernel_threads = kernel_threads;
13824 device_param->kernel_power_user = kernel_power;
13825
13826 kernel_power_all += kernel_power;
13827
13828 /**
13829 * default building options
13830 */
13831
13832 char build_opts[1024] = { 0 };
13833
13834 // we don't have sm_* on vendors not NV but it doesn't matter
13835
13836 snprintf (build_opts, sizeof (build_opts) - 1, "-I\"%s/\" -DVENDOR_ID=%u -DCUDA_ARCH=%d -DVECT_SIZE=%u -DDEVICE_TYPE=%u", shared_dir, device_param->vendor_id, (device_param->sm_major * 100) + device_param->sm_minor, device_param->vector_width, (u32) device_param->device_type);
13837
13838 /**
13839 * main kernel
13840 */
13841
13842 {
13843 /**
13844 * kernel source filename
13845 */
13846
13847 char source_file[256] = { 0 };
13848
13849 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13850
13851 struct stat sst;
13852
13853 if (stat (source_file, &sst) == -1)
13854 {
13855 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13856
13857 return -1;
13858 }
13859
13860 /**
13861 * kernel cached filename
13862 */
13863
13864 char cached_file[256] = { 0 };
13865
13866 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
13867
13868 int cached = 1;
13869
13870 struct stat cst;
13871
13872 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
13873 {
13874 cached = 0;
13875 }
13876
13877 /**
13878 * kernel compile or load
13879 */
13880
13881 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13882
13883 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13884
13885 if (force_jit_compilation == -1)
13886 {
13887 if (cached == 0)
13888 {
13889 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13890
13891 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13892
13893 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13894
13895 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
13896
13897 #ifdef DEBUG
13898 size_t build_log_size = 0;
13899
13900 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
13901
13902 if (build_log_size > 1)
13903 {
13904 char *build_log = (char *) malloc (build_log_size + 1);
13905
13906 memset (build_log, 0, build_log_size + 1);
13907
13908 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
13909
13910 puts (build_log);
13911
13912 free (build_log);
13913 }
13914 #endif
13915
13916 if (rc != 0)
13917 {
13918 device_param->skipped = true;
13919 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13920 continue;
13921 }
13922
13923 size_t binary_size;
13924
13925 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13926
13927 u8 *binary = (u8 *) mymalloc (binary_size);
13928
13929 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13930
13931 writeProgramBin (cached_file, binary, binary_size);
13932
13933 local_free (binary);
13934 }
13935 else
13936 {
13937 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13938
13939 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13940
13941 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13942
13943 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
13944 }
13945 }
13946 else
13947 {
13948 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13949
13950 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13951
13952 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13953
13954 char build_opts_update[1024] = { 0 };
13955
13956 if (force_jit_compilation == 1500)
13957 {
13958 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13959 }
13960 else if (force_jit_compilation == 8900)
13961 {
13962 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);
13963 }
13964 else
13965 {
13966 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
13967 }
13968
13969 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
13970
13971 #ifdef DEBUG
13972 size_t build_log_size = 0;
13973
13974 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
13975
13976 if (build_log_size > 1)
13977 {
13978 char *build_log = (char *) malloc (build_log_size + 1);
13979
13980 memset (build_log, 0, build_log_size + 1);
13981
13982 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
13983
13984 puts (build_log);
13985
13986 free (build_log);
13987 }
13988 #endif
13989
13990 if (rc != 0)
13991 {
13992 device_param->skipped = true;
13993
13994 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13995 }
13996 }
13997
13998 local_free (kernel_lengths);
13999 local_free (kernel_sources[0]);
14000 local_free (kernel_sources);
14001 }
14002
14003 /**
14004 * word generator kernel
14005 */
14006
14007 if (attack_mode != ATTACK_MODE_STRAIGHT)
14008 {
14009 /**
14010 * kernel mp source filename
14011 */
14012
14013 char source_file[256] = { 0 };
14014
14015 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
14016
14017 struct stat sst;
14018
14019 if (stat (source_file, &sst) == -1)
14020 {
14021 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14022
14023 return -1;
14024 }
14025
14026 /**
14027 * kernel mp cached filename
14028 */
14029
14030 char cached_file[256] = { 0 };
14031
14032 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
14033
14034 int cached = 1;
14035
14036 struct stat cst;
14037
14038 if (stat (cached_file, &cst) == -1)
14039 {
14040 cached = 0;
14041 }
14042
14043 /**
14044 * kernel compile or load
14045 */
14046
14047 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14048
14049 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14050
14051 if (cached == 0)
14052 {
14053 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14054
14055 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14056
14057 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14058
14059 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
14060
14061 if (rc != 0)
14062 {
14063 device_param->skipped = true;
14064 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14065 continue;
14066 }
14067
14068 size_t binary_size;
14069
14070 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14071
14072 u8 *binary = (u8 *) mymalloc (binary_size);
14073
14074 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14075
14076 writeProgramBin (cached_file, binary, binary_size);
14077
14078 local_free (binary);
14079 }
14080 else
14081 {
14082 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14083
14084 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14085
14086 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14087
14088 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
14089 }
14090
14091 local_free (kernel_lengths);
14092 local_free (kernel_sources[0]);
14093 local_free (kernel_sources);
14094 }
14095
14096 /**
14097 * amplifier kernel
14098 */
14099
14100 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14101 {
14102
14103 }
14104 else
14105 {
14106 /**
14107 * kernel amp source filename
14108 */
14109
14110 char source_file[256] = { 0 };
14111
14112 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
14113
14114 struct stat sst;
14115
14116 if (stat (source_file, &sst) == -1)
14117 {
14118 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14119
14120 return -1;
14121 }
14122
14123 /**
14124 * kernel amp cached filename
14125 */
14126
14127 char cached_file[256] = { 0 };
14128
14129 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
14130
14131 int cached = 1;
14132
14133 struct stat cst;
14134
14135 if (stat (cached_file, &cst) == -1)
14136 {
14137 cached = 0;
14138 }
14139
14140 /**
14141 * kernel compile or load
14142 */
14143
14144 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14145
14146 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14147
14148 if (cached == 0)
14149 {
14150 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14151
14152 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14153
14154 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14155
14156 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
14157
14158 if (rc != 0)
14159 {
14160 device_param->skipped = true;
14161 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14162 continue;
14163 }
14164
14165 size_t binary_size;
14166
14167 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14168
14169 u8 *binary = (u8 *) mymalloc (binary_size);
14170
14171 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14172
14173 writeProgramBin (cached_file, binary, binary_size);
14174
14175 local_free (binary);
14176 }
14177 else
14178 {
14179 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14180
14181 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14182
14183 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14184
14185 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
14186 }
14187
14188 local_free (kernel_lengths);
14189 local_free (kernel_sources[0]);
14190 local_free (kernel_sources);
14191 }
14192
14193 // some algorithm collide too fast, make that impossible
14194
14195 if (benchmark == 1)
14196 {
14197 ((uint *) digests_buf)[0] = -1;
14198 ((uint *) digests_buf)[1] = -1;
14199 ((uint *) digests_buf)[2] = -1;
14200 ((uint *) digests_buf)[3] = -1;
14201 }
14202
14203 /**
14204 * global buffers
14205 */
14206
14207 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14208 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14209 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
14210 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
14211 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14212 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14213 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14214 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14215 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14216 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14217 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14218 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14219 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
14220 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
14221 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
14222 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
14223 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
14224 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
14225
14226 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);
14227 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);
14228 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);
14229 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);
14230 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);
14231 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);
14232 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);
14233 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);
14234 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
14235 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
14236 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
14237
14238 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
14239 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
14240 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
14241 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
14242 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
14243 run_kernel_bzero (device_param, device_param->d_result, size_results);
14244
14245 /**
14246 * special buffers
14247 */
14248
14249 if (attack_kern == ATTACK_KERN_STRAIGHT)
14250 {
14251 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
14252 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
14253
14254 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
14255
14256 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
14257 }
14258 else if (attack_kern == ATTACK_KERN_COMBI)
14259 {
14260 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14261 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14262 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14263 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14264
14265 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
14266 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
14267 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14268 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14269 }
14270 else if (attack_kern == ATTACK_KERN_BF)
14271 {
14272 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14273 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14274 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
14275 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14276 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14277
14278 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
14279 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
14280 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
14281 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14282 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14283 }
14284
14285 if (size_esalts)
14286 {
14287 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
14288
14289 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
14290 }
14291
14292 /**
14293 * main host data
14294 */
14295
14296 uint *result = (uint *) mymalloc (size_results);
14297
14298 device_param->result = result;
14299
14300 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
14301
14302 device_param->pws_buf = pws_buf;
14303
14304 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
14305
14306 device_param->combs_buf = combs_buf;
14307
14308 void *hooks_buf = mymalloc (size_hooks);
14309
14310 device_param->hooks_buf = hooks_buf;
14311
14312 /**
14313 * kernel args
14314 */
14315
14316 device_param->kernel_params_buf32[21] = bitmap_mask;
14317 device_param->kernel_params_buf32[22] = bitmap_shift1;
14318 device_param->kernel_params_buf32[23] = bitmap_shift2;
14319 device_param->kernel_params_buf32[24] = 0; // salt_pos
14320 device_param->kernel_params_buf32[25] = 0; // loop_pos
14321 device_param->kernel_params_buf32[26] = 0; // loop_cnt
14322 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
14323 device_param->kernel_params_buf32[28] = 0; // digests_cnt
14324 device_param->kernel_params_buf32[29] = 0; // digests_offset
14325 device_param->kernel_params_buf32[30] = 0; // combs_mode
14326 device_param->kernel_params_buf32[31] = 0; // gid_max
14327
14328 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14329 ? &device_param->d_pws_buf
14330 : &device_param->d_pws_amp_buf;
14331 device_param->kernel_params[ 1] = &device_param->d_rules_c;
14332 device_param->kernel_params[ 2] = &device_param->d_combs_c;
14333 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
14334 device_param->kernel_params[ 4] = &device_param->d_tmps;
14335 device_param->kernel_params[ 5] = &device_param->d_hooks;
14336 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
14337 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
14338 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
14339 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
14340 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
14341 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
14342 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
14343 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
14344 device_param->kernel_params[14] = &device_param->d_plain_bufs;
14345 device_param->kernel_params[15] = &device_param->d_digests_buf;
14346 device_param->kernel_params[16] = &device_param->d_digests_shown;
14347 device_param->kernel_params[17] = &device_param->d_salt_bufs;
14348 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
14349 device_param->kernel_params[19] = &device_param->d_result;
14350 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
14351 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
14352 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
14353 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
14354 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
14355 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
14356 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
14357 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
14358 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
14359 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
14360 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
14361 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
14362
14363 device_param->kernel_params_mp_buf64[3] = 0;
14364 device_param->kernel_params_mp_buf32[4] = 0;
14365 device_param->kernel_params_mp_buf32[5] = 0;
14366 device_param->kernel_params_mp_buf32[6] = 0;
14367 device_param->kernel_params_mp_buf32[7] = 0;
14368 device_param->kernel_params_mp_buf32[8] = 0;
14369
14370 device_param->kernel_params_mp[0] = NULL;
14371 device_param->kernel_params_mp[1] = NULL;
14372 device_param->kernel_params_mp[2] = NULL;
14373 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
14374 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
14375 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
14376 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
14377 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
14378 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
14379
14380 device_param->kernel_params_mp_l_buf64[3] = 0;
14381 device_param->kernel_params_mp_l_buf32[4] = 0;
14382 device_param->kernel_params_mp_l_buf32[5] = 0;
14383 device_param->kernel_params_mp_l_buf32[6] = 0;
14384 device_param->kernel_params_mp_l_buf32[7] = 0;
14385 device_param->kernel_params_mp_l_buf32[8] = 0;
14386 device_param->kernel_params_mp_l_buf32[9] = 0;
14387
14388 device_param->kernel_params_mp_l[0] = NULL;
14389 device_param->kernel_params_mp_l[1] = NULL;
14390 device_param->kernel_params_mp_l[2] = NULL;
14391 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14392 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14393 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14394 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14395 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14396 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14397 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14398
14399 device_param->kernel_params_mp_r_buf64[3] = 0;
14400 device_param->kernel_params_mp_r_buf32[4] = 0;
14401 device_param->kernel_params_mp_r_buf32[5] = 0;
14402 device_param->kernel_params_mp_r_buf32[6] = 0;
14403 device_param->kernel_params_mp_r_buf32[7] = 0;
14404 device_param->kernel_params_mp_r_buf32[8] = 0;
14405
14406 device_param->kernel_params_mp_r[0] = NULL;
14407 device_param->kernel_params_mp_r[1] = NULL;
14408 device_param->kernel_params_mp_r[2] = NULL;
14409 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14410 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14411 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14412 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14413 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14414 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14415
14416 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14417 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14418
14419 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14420 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14421 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14422 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14423 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14424 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14425 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14426
14427 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14428 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14429
14430 /**
14431 * kernel name
14432 */
14433
14434 char kernel_name[64] = { 0 };
14435
14436 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14437 {
14438 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14439 {
14440 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14441
14442 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14443
14444 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14445
14446 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14447
14448 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14449
14450 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14451 }
14452 else
14453 {
14454 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14455
14456 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14457
14458 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14459
14460 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14461
14462 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14463
14464 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14465 }
14466
14467 if (data.attack_mode == ATTACK_MODE_BF)
14468 {
14469 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14470 {
14471 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14472
14473 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14474 }
14475 }
14476 }
14477 else
14478 {
14479 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14480
14481 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14482
14483 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14484
14485 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14486
14487 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14488
14489 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14490
14491 if (opts_type & OPTS_TYPE_HOOK12)
14492 {
14493 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14494
14495 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14496 }
14497
14498 if (opts_type & OPTS_TYPE_HOOK23)
14499 {
14500 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14501
14502 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14503 }
14504 }
14505
14506 for (uint i = 0; i <= 20; i++)
14507 {
14508 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14509 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14510 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14511
14512 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14513 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14514 }
14515
14516 for (uint i = 21; i <= 31; i++)
14517 {
14518 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14519 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14520 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14521
14522 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14523 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14524 }
14525
14526 if (attack_mode == ATTACK_MODE_BF)
14527 {
14528 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
14529 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
14530
14531 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14532 {
14533 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14534 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14535 }
14536 }
14537 else if (attack_mode == ATTACK_MODE_HYBRID1)
14538 {
14539 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14540 }
14541 else if (attack_mode == ATTACK_MODE_HYBRID2)
14542 {
14543 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14544 }
14545
14546 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14547 {
14548 // nothing to do
14549 }
14550 else
14551 {
14552 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
14553 }
14554
14555 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14556 {
14557 // nothing to do
14558 }
14559 else
14560 {
14561 for (uint i = 0; i < 5; i++)
14562 {
14563 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14564 }
14565
14566 for (uint i = 5; i < 7; i++)
14567 {
14568 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14569 }
14570 }
14571
14572 /**
14573 * Store initial fanspeed if gpu_temp_retain is enabled
14574 */
14575
14576 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
14577 int gpu_temp_retain_set = 0;
14578
14579 if (gpu_temp_disable == 0)
14580 {
14581 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14582 {
14583 hc_thread_mutex_lock (mux_adl);
14584
14585 if (data.hm_device[device_id].fan_supported == 1)
14586 {
14587 if (gpu_temp_retain_chgd == 0)
14588 {
14589 uint cur_temp = 0;
14590 uint default_temp = 0;
14591
14592 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);
14593
14594 if (ADL_rc == ADL_OK)
14595 {
14596 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14597
14598 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14599
14600 // special case with multi gpu setups: always use minimum retain
14601
14602 if (gpu_temp_retain_set == 0)
14603 {
14604 gpu_temp_retain = gpu_temp_retain_target;
14605 gpu_temp_retain_set = 1;
14606 }
14607 else
14608 {
14609 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14610 }
14611
14612 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14613 }
14614 }
14615
14616 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14617
14618 temp_retain_fanspeed_value[device_id] = fan_speed;
14619
14620 if (fan_speed == -1)
14621 {
14622 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14623
14624 temp_retain_fanspeed_value[device_id] = 0;
14625 }
14626 }
14627
14628 hc_thread_mutex_unlock (mux_adl);
14629 }
14630 }
14631
14632 /**
14633 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14634 */
14635
14636 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14637 {
14638 hc_thread_mutex_lock (mux_adl);
14639
14640 if (data.hm_device[device_id].od_version == 6)
14641 {
14642 int ADL_rc;
14643
14644 // check powertune capabilities first, if not available then skip device
14645
14646 int powertune_supported = 0;
14647
14648 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14649 {
14650 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14651
14652 return (-1);
14653 }
14654
14655 if (powertune_supported != 0)
14656 {
14657 // powercontrol settings
14658
14659 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14660
14661 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14662 {
14663 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14664 }
14665
14666 if (ADL_rc != ADL_OK)
14667 {
14668 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14669
14670 return (-1);
14671 }
14672
14673 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14674 {
14675 log_error ("ERROR: Failed to set new ADL PowerControl values");
14676
14677 return (-1);
14678 }
14679
14680 // clocks
14681
14682 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14683
14684 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14685
14686 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)
14687 {
14688 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14689
14690 return (-1);
14691 }
14692
14693 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14694
14695 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14696
14697 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14698 {
14699 log_error ("ERROR: Failed to get ADL device capabilities");
14700
14701 return (-1);
14702 }
14703
14704 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14705 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14706
14707 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14708 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14709
14710 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14711 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14712
14713 // warning if profile has too low max values
14714
14715 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14716 {
14717 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14718 }
14719
14720 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14721 {
14722 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14723 }
14724
14725 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14726
14727 performance_state->iNumberOfPerformanceLevels = 2;
14728
14729 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14730 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14731 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14732 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14733
14734 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)
14735 {
14736 log_info ("ERROR: Failed to set ADL performance state");
14737
14738 return (-1);
14739 }
14740
14741 local_free (performance_state);
14742 }
14743 }
14744
14745 hc_thread_mutex_unlock (mux_adl);
14746 }
14747 #endif // HAVE_HWMON && HAVE_ADL
14748 }
14749
14750 data.kernel_power_all = kernel_power_all;
14751
14752 if (data.quiet == 0) log_info ("");
14753
14754 /**
14755 * Inform user which algorithm is checked and at which workload setting
14756 */
14757
14758 if (benchmark == 1)
14759 {
14760 quiet = 0;
14761
14762 data.quiet = quiet;
14763
14764 char *hash_type = strhashtype (data.hash_mode); // not a bug
14765
14766 log_info ("Hashtype: %s", hash_type);
14767 log_info ("");
14768 }
14769
14770 /**
14771 * keep track of the progress
14772 */
14773
14774 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14775 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14776 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14777
14778 /**
14779 * open filehandles
14780 */
14781
14782 #if _WIN
14783 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14784 {
14785 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14786
14787 return (-1);
14788 }
14789
14790 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14791 {
14792 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14793
14794 return (-1);
14795 }
14796
14797 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14798 {
14799 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14800
14801 return (-1);
14802 }
14803 #endif
14804
14805 /**
14806 * dictionary pad
14807 */
14808
14809 segment_size *= (1024 * 1024);
14810
14811 data.segment_size = segment_size;
14812
14813 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14814
14815 wl_data->buf = (char *) mymalloc (segment_size);
14816 wl_data->avail = segment_size;
14817 wl_data->incr = segment_size;
14818 wl_data->cnt = 0;
14819 wl_data->pos = 0;
14820
14821 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14822
14823 data.wordlist_mode = wordlist_mode;
14824
14825 cs_t *css_buf = NULL;
14826 uint css_cnt = 0;
14827 uint dictcnt = 0;
14828 uint maskcnt = 1;
14829 char **masks = NULL;
14830 char **dictfiles = NULL;
14831
14832 uint mask_from_file = 0;
14833
14834 if (attack_mode == ATTACK_MODE_STRAIGHT)
14835 {
14836 if (wordlist_mode == WL_MODE_FILE)
14837 {
14838 int wls_left = myargc - (optind + 1);
14839
14840 for (int i = 0; i < wls_left; i++)
14841 {
14842 char *l0_filename = myargv[optind + 1 + i];
14843
14844 struct stat l0_stat;
14845
14846 if (stat (l0_filename, &l0_stat) == -1)
14847 {
14848 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14849
14850 return (-1);
14851 }
14852
14853 uint is_dir = S_ISDIR (l0_stat.st_mode);
14854
14855 if (is_dir == 0)
14856 {
14857 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14858
14859 dictcnt++;
14860
14861 dictfiles[dictcnt - 1] = l0_filename;
14862 }
14863 else
14864 {
14865 // do not allow --keyspace w/ a directory
14866
14867 if (keyspace == 1)
14868 {
14869 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14870
14871 return (-1);
14872 }
14873
14874 char **dictionary_files = NULL;
14875
14876 dictionary_files = scan_directory (l0_filename);
14877
14878 if (dictionary_files != NULL)
14879 {
14880 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14881
14882 for (int d = 0; dictionary_files[d] != NULL; d++)
14883 {
14884 char *l1_filename = dictionary_files[d];
14885
14886 struct stat l1_stat;
14887
14888 if (stat (l1_filename, &l1_stat) == -1)
14889 {
14890 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14891
14892 return (-1);
14893 }
14894
14895 if (S_ISREG (l1_stat.st_mode))
14896 {
14897 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14898
14899 dictcnt++;
14900
14901 dictfiles[dictcnt - 1] = strdup (l1_filename);
14902 }
14903 }
14904 }
14905
14906 local_free (dictionary_files);
14907 }
14908 }
14909
14910 if (dictcnt < 1)
14911 {
14912 log_error ("ERROR: No usable dictionary file found.");
14913
14914 return (-1);
14915 }
14916 }
14917 else if (wordlist_mode == WL_MODE_STDIN)
14918 {
14919 dictcnt = 1;
14920 }
14921 }
14922 else if (attack_mode == ATTACK_MODE_COMBI)
14923 {
14924 // display
14925
14926 char *dictfile1 = myargv[optind + 1 + 0];
14927 char *dictfile2 = myargv[optind + 1 + 1];
14928
14929 // find the bigger dictionary and use as base
14930
14931 FILE *fp1 = NULL;
14932 FILE *fp2 = NULL;
14933
14934 struct stat tmp_stat;
14935
14936 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14937 {
14938 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14939
14940 return (-1);
14941 }
14942
14943 if (stat (dictfile1, &tmp_stat) == -1)
14944 {
14945 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14946
14947 fclose (fp1);
14948
14949 return (-1);
14950 }
14951
14952 if (S_ISDIR (tmp_stat.st_mode))
14953 {
14954 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14955
14956 fclose (fp1);
14957
14958 return (-1);
14959 }
14960
14961 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14962 {
14963 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14964
14965 fclose (fp1);
14966
14967 return (-1);
14968 }
14969
14970 if (stat (dictfile2, &tmp_stat) == -1)
14971 {
14972 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14973
14974 fclose (fp1);
14975 fclose (fp2);
14976
14977 return (-1);
14978 }
14979
14980 if (S_ISDIR (tmp_stat.st_mode))
14981 {
14982 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
14983
14984 fclose (fp1);
14985 fclose (fp2);
14986
14987 return (-1);
14988 }
14989
14990 data.combs_cnt = 1;
14991
14992 data.quiet = 1;
14993
14994 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
14995
14996 data.quiet = quiet;
14997
14998 if (words1_cnt == 0)
14999 {
15000 log_error ("ERROR: %s: empty file", dictfile1);
15001
15002 fclose (fp1);
15003 fclose (fp2);
15004
15005 return (-1);
15006 }
15007
15008 data.combs_cnt = 1;
15009
15010 data.quiet = 1;
15011
15012 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
15013
15014 data.quiet = quiet;
15015
15016 if (words2_cnt == 0)
15017 {
15018 log_error ("ERROR: %s: empty file", dictfile2);
15019
15020 fclose (fp1);
15021 fclose (fp2);
15022
15023 return (-1);
15024 }
15025
15026 fclose (fp1);
15027 fclose (fp2);
15028
15029 data.dictfile = dictfile1;
15030 data.dictfile2 = dictfile2;
15031
15032 if (words1_cnt >= words2_cnt)
15033 {
15034 data.combs_cnt = words2_cnt;
15035 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15036
15037 dictfiles = &data.dictfile;
15038
15039 dictcnt = 1;
15040 }
15041 else
15042 {
15043 data.combs_cnt = words1_cnt;
15044 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15045
15046 dictfiles = &data.dictfile2;
15047
15048 dictcnt = 1;
15049
15050 // we also have to switch wordlist related rules!
15051
15052 char *tmpc = data.rule_buf_l;
15053
15054 data.rule_buf_l = data.rule_buf_r;
15055 data.rule_buf_r = tmpc;
15056
15057 int tmpi = data.rule_len_l;
15058
15059 data.rule_len_l = data.rule_len_r;
15060 data.rule_len_r = tmpi;
15061 }
15062 }
15063 else if (attack_mode == ATTACK_MODE_BF)
15064 {
15065 char *mask = NULL;
15066
15067 maskcnt = 0;
15068
15069 if (benchmark == 0)
15070 {
15071 mask = myargv[optind + 1];
15072
15073 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
15074
15075 if ((optind + 2) <= myargc)
15076 {
15077 struct stat file_stat;
15078
15079 if (stat (mask, &file_stat) == -1)
15080 {
15081 maskcnt = 1;
15082
15083 masks[maskcnt - 1] = mystrdup (mask);
15084 }
15085 else
15086 {
15087 int wls_left = myargc - (optind + 1);
15088
15089 uint masks_avail = INCR_MASKS;
15090
15091 for (int i = 0; i < wls_left; i++)
15092 {
15093 if (i != 0)
15094 {
15095 mask = myargv[optind + 1 + i];
15096
15097 if (stat (mask, &file_stat) == -1)
15098 {
15099 log_error ("ERROR: %s: %s", mask, strerror (errno));
15100
15101 return (-1);
15102 }
15103 }
15104
15105 uint is_file = S_ISREG (file_stat.st_mode);
15106
15107 if (is_file == 1)
15108 {
15109 FILE *mask_fp;
15110
15111 if ((mask_fp = fopen (mask, "r")) == NULL)
15112 {
15113 log_error ("ERROR: %s: %s", mask, strerror (errno));
15114
15115 return (-1);
15116 }
15117
15118 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15119
15120 while (!feof (mask_fp))
15121 {
15122 memset (line_buf, 0, HCBUFSIZ);
15123
15124 int line_len = fgetl (mask_fp, line_buf);
15125
15126 if (line_len == 0) continue;
15127
15128 if (line_buf[0] == '#') continue;
15129
15130 if (masks_avail == maskcnt)
15131 {
15132 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15133
15134 masks_avail += INCR_MASKS;
15135 }
15136
15137 masks[maskcnt] = mystrdup (line_buf);
15138
15139 maskcnt++;
15140 }
15141
15142 myfree (line_buf);
15143
15144 fclose (mask_fp);
15145 }
15146 else
15147 {
15148 log_error ("ERROR: %s: unsupported file-type", mask);
15149
15150 return (-1);
15151 }
15152 }
15153
15154 mask_from_file = 1;
15155 }
15156 }
15157 else
15158 {
15159 custom_charset_1 = (char *) "?l?d?u";
15160 custom_charset_2 = (char *) "?l?d";
15161 custom_charset_3 = (char *) "?l?d*!$@_";
15162
15163 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15164 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15165 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15166
15167 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
15168
15169 wordlist_mode = WL_MODE_MASK;
15170
15171 data.wordlist_mode = wordlist_mode;
15172
15173 increment = 1;
15174
15175 maskcnt = 1;
15176 }
15177 }
15178 else
15179 {
15180 /**
15181 * generate full masks and charsets
15182 */
15183
15184 masks = (char **) mymalloc (sizeof (char *));
15185
15186 switch (hash_mode)
15187 {
15188 case 1731: pw_min = 5;
15189 pw_max = 5;
15190 mask = mystrdup ("?b?b?b?b?b");
15191 break;
15192 case 12500: pw_min = 5;
15193 pw_max = 5;
15194 mask = mystrdup ("?b?b?b?b?b");
15195 break;
15196 default: pw_min = 7;
15197 pw_max = 7;
15198 mask = mystrdup ("?b?b?b?b?b?b?b");
15199 break;
15200 }
15201
15202 maskcnt = 1;
15203
15204 masks[maskcnt - 1] = mystrdup (mask);
15205
15206 wordlist_mode = WL_MODE_MASK;
15207
15208 data.wordlist_mode = wordlist_mode;
15209
15210 increment = 1;
15211 }
15212
15213 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
15214
15215 if (increment)
15216 {
15217 if (increment_min > pw_min) pw_min = increment_min;
15218
15219 if (increment_max < pw_max) pw_max = increment_max;
15220 }
15221 }
15222 else if (attack_mode == ATTACK_MODE_HYBRID1)
15223 {
15224 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15225
15226 // display
15227
15228 char *mask = myargv[myargc - 1];
15229
15230 maskcnt = 0;
15231
15232 masks = (char **) mymalloc (1 * sizeof (char *));
15233
15234 // mod
15235
15236 struct stat file_stat;
15237
15238 if (stat (mask, &file_stat) == -1)
15239 {
15240 maskcnt = 1;
15241
15242 masks[maskcnt - 1] = mystrdup (mask);
15243 }
15244 else
15245 {
15246 uint is_file = S_ISREG (file_stat.st_mode);
15247
15248 if (is_file == 1)
15249 {
15250 FILE *mask_fp;
15251
15252 if ((mask_fp = fopen (mask, "r")) == NULL)
15253 {
15254 log_error ("ERROR: %s: %s", mask, strerror (errno));
15255
15256 return (-1);
15257 }
15258
15259 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15260
15261 uint masks_avail = 1;
15262
15263 while (!feof (mask_fp))
15264 {
15265 memset (line_buf, 0, HCBUFSIZ);
15266
15267 int line_len = fgetl (mask_fp, line_buf);
15268
15269 if (line_len == 0) continue;
15270
15271 if (line_buf[0] == '#') continue;
15272
15273 if (masks_avail == maskcnt)
15274 {
15275 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15276
15277 masks_avail += INCR_MASKS;
15278 }
15279
15280 masks[maskcnt] = mystrdup (line_buf);
15281
15282 maskcnt++;
15283 }
15284
15285 myfree (line_buf);
15286
15287 fclose (mask_fp);
15288
15289 mask_from_file = 1;
15290 }
15291 else
15292 {
15293 maskcnt = 1;
15294
15295 masks[maskcnt - 1] = mystrdup (mask);
15296 }
15297 }
15298
15299 // base
15300
15301 int wls_left = myargc - (optind + 2);
15302
15303 for (int i = 0; i < wls_left; i++)
15304 {
15305 char *filename = myargv[optind + 1 + i];
15306
15307 struct stat file_stat;
15308
15309 if (stat (filename, &file_stat) == -1)
15310 {
15311 log_error ("ERROR: %s: %s", filename, strerror (errno));
15312
15313 return (-1);
15314 }
15315
15316 uint is_dir = S_ISDIR (file_stat.st_mode);
15317
15318 if (is_dir == 0)
15319 {
15320 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15321
15322 dictcnt++;
15323
15324 dictfiles[dictcnt - 1] = filename;
15325 }
15326 else
15327 {
15328 // do not allow --keyspace w/ a directory
15329
15330 if (keyspace == 1)
15331 {
15332 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15333
15334 return (-1);
15335 }
15336
15337 char **dictionary_files = NULL;
15338
15339 dictionary_files = scan_directory (filename);
15340
15341 if (dictionary_files != NULL)
15342 {
15343 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15344
15345 for (int d = 0; dictionary_files[d] != NULL; d++)
15346 {
15347 char *l1_filename = dictionary_files[d];
15348
15349 struct stat l1_stat;
15350
15351 if (stat (l1_filename, &l1_stat) == -1)
15352 {
15353 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15354
15355 return (-1);
15356 }
15357
15358 if (S_ISREG (l1_stat.st_mode))
15359 {
15360 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15361
15362 dictcnt++;
15363
15364 dictfiles[dictcnt - 1] = strdup (l1_filename);
15365 }
15366 }
15367 }
15368
15369 local_free (dictionary_files);
15370 }
15371 }
15372
15373 if (dictcnt < 1)
15374 {
15375 log_error ("ERROR: No usable dictionary file found.");
15376
15377 return (-1);
15378 }
15379
15380 if (increment)
15381 {
15382 maskcnt = 0;
15383
15384 uint mask_min = increment_min; // we can't reject smaller masks here
15385 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15386
15387 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15388 {
15389 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15390
15391 if (cur_mask == NULL) break;
15392
15393 masks[maskcnt] = cur_mask;
15394
15395 maskcnt++;
15396
15397 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15398 }
15399 }
15400 }
15401 else if (attack_mode == ATTACK_MODE_HYBRID2)
15402 {
15403 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15404
15405 // display
15406
15407 char *mask = myargv[optind + 1 + 0];
15408
15409 maskcnt = 0;
15410
15411 masks = (char **) mymalloc (1 * sizeof (char *));
15412
15413 // mod
15414
15415 struct stat file_stat;
15416
15417 if (stat (mask, &file_stat) == -1)
15418 {
15419 maskcnt = 1;
15420
15421 masks[maskcnt - 1] = mystrdup (mask);
15422 }
15423 else
15424 {
15425 uint is_file = S_ISREG (file_stat.st_mode);
15426
15427 if (is_file == 1)
15428 {
15429 FILE *mask_fp;
15430
15431 if ((mask_fp = fopen (mask, "r")) == NULL)
15432 {
15433 log_error ("ERROR: %s: %s", mask, strerror (errno));
15434
15435 return (-1);
15436 }
15437
15438 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15439
15440 uint masks_avail = 1;
15441
15442 while (!feof (mask_fp))
15443 {
15444 memset (line_buf, 0, HCBUFSIZ);
15445
15446 int line_len = fgetl (mask_fp, line_buf);
15447
15448 if (line_len == 0) continue;
15449
15450 if (line_buf[0] == '#') continue;
15451
15452 if (masks_avail == maskcnt)
15453 {
15454 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15455
15456 masks_avail += INCR_MASKS;
15457 }
15458
15459 masks[maskcnt] = mystrdup (line_buf);
15460
15461 maskcnt++;
15462 }
15463
15464 myfree (line_buf);
15465
15466 fclose (mask_fp);
15467
15468 mask_from_file = 1;
15469 }
15470 else
15471 {
15472 maskcnt = 1;
15473
15474 masks[maskcnt - 1] = mystrdup (mask);
15475 }
15476 }
15477
15478 // base
15479
15480 int wls_left = myargc - (optind + 2);
15481
15482 for (int i = 0; i < wls_left; i++)
15483 {
15484 char *filename = myargv[optind + 2 + i];
15485
15486 struct stat file_stat;
15487
15488 if (stat (filename, &file_stat) == -1)
15489 {
15490 log_error ("ERROR: %s: %s", filename, strerror (errno));
15491
15492 return (-1);
15493 }
15494
15495 uint is_dir = S_ISDIR (file_stat.st_mode);
15496
15497 if (is_dir == 0)
15498 {
15499 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15500
15501 dictcnt++;
15502
15503 dictfiles[dictcnt - 1] = filename;
15504 }
15505 else
15506 {
15507 // do not allow --keyspace w/ a directory
15508
15509 if (keyspace == 1)
15510 {
15511 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15512
15513 return (-1);
15514 }
15515
15516 char **dictionary_files = NULL;
15517
15518 dictionary_files = scan_directory (filename);
15519
15520 if (dictionary_files != NULL)
15521 {
15522 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15523
15524 for (int d = 0; dictionary_files[d] != NULL; d++)
15525 {
15526 char *l1_filename = dictionary_files[d];
15527
15528 struct stat l1_stat;
15529
15530 if (stat (l1_filename, &l1_stat) == -1)
15531 {
15532 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15533
15534 return (-1);
15535 }
15536
15537 if (S_ISREG (l1_stat.st_mode))
15538 {
15539 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15540
15541 dictcnt++;
15542
15543 dictfiles[dictcnt - 1] = strdup (l1_filename);
15544 }
15545 }
15546 }
15547
15548 local_free (dictionary_files);
15549 }
15550 }
15551
15552 if (dictcnt < 1)
15553 {
15554 log_error ("ERROR: No usable dictionary file found.");
15555
15556 return (-1);
15557 }
15558
15559 if (increment)
15560 {
15561 maskcnt = 0;
15562
15563 uint mask_min = increment_min; // we can't reject smaller masks here
15564 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15565
15566 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15567 {
15568 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15569
15570 if (cur_mask == NULL) break;
15571
15572 masks[maskcnt] = cur_mask;
15573
15574 maskcnt++;
15575
15576 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15577 }
15578 }
15579 }
15580
15581 data.pw_min = pw_min;
15582 data.pw_max = pw_max;
15583
15584 /**
15585 * weak hash check
15586 */
15587
15588 if (weak_hash_threshold >= salts_cnt)
15589 {
15590 hc_device_param_t *device_param = NULL;
15591
15592 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15593 {
15594 device_param = &data.devices_param[device_id];
15595
15596 if (device_param->skipped) continue;
15597
15598 break;
15599 }
15600
15601 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15602
15603 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15604 {
15605 weak_hash_check (device_param, salt_pos);
15606 }
15607 }
15608
15609 // Display hack, guarantee that there is at least one \r before real start
15610
15611 if (data.quiet == 0) log_info_nn ("");
15612
15613 /**
15614 * status and monitor threads
15615 */
15616
15617 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15618
15619 hc_thread_t i_thread = 0;
15620
15621 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15622 {
15623 hc_thread_create (i_thread, thread_keypress, &benchmark);
15624 }
15625
15626 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15627
15628 uint ni_threads_cnt = 0;
15629
15630 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15631
15632 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15633
15634 ni_threads_cnt++;
15635
15636 /**
15637 * Outfile remove
15638 */
15639
15640 if (keyspace == 0)
15641 {
15642 if (outfile_check_timer != 0)
15643 {
15644 if (data.outfile_check_directory != NULL)
15645 {
15646 if ((hash_mode != 5200) &&
15647 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15648 (hash_mode != 9000))
15649 {
15650 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15651
15652 ni_threads_cnt++;
15653 }
15654 else
15655 {
15656 outfile_check_timer = 0;
15657 }
15658 }
15659 else
15660 {
15661 outfile_check_timer = 0;
15662 }
15663 }
15664 }
15665
15666 /**
15667 * Inform the user if we got some hashes remove because of the pot file remove feature
15668 */
15669
15670 if (data.quiet == 0)
15671 {
15672 if (potfile_remove_cracks > 0)
15673 {
15674 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15675 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15676 }
15677 }
15678
15679 data.outfile_check_timer = outfile_check_timer;
15680
15681 /**
15682 * main loop
15683 */
15684
15685 char **induction_dictionaries = NULL;
15686
15687 int induction_dictionaries_cnt = 0;
15688
15689 hcstat_table_t *root_table_buf = NULL;
15690 hcstat_table_t *markov_table_buf = NULL;
15691
15692 uint initial_restore_done = 0;
15693
15694 data.maskcnt = maskcnt;
15695
15696 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15697 {
15698 if (data.devices_status == STATUS_CRACKED) break;
15699
15700 data.devices_status = STATUS_INIT;
15701
15702 if (maskpos > rd->maskpos)
15703 {
15704 rd->dictpos = 0;
15705 }
15706
15707 rd->maskpos = maskpos;
15708 data.maskpos = maskpos;
15709
15710 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15711 {
15712 char *mask = masks[maskpos];
15713
15714 if (mask_from_file == 1)
15715 {
15716 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15717
15718 char *str_ptr;
15719 uint str_pos;
15720
15721 uint mask_offset = 0;
15722
15723 uint separator_cnt;
15724
15725 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15726 {
15727 str_ptr = strstr (mask + mask_offset, ",");
15728
15729 if (str_ptr == NULL) break;
15730
15731 str_pos = str_ptr - mask;
15732
15733 // escaped separator, i.e. "\,"
15734
15735 if (str_pos > 0)
15736 {
15737 if (mask[str_pos - 1] == '\\')
15738 {
15739 separator_cnt --;
15740
15741 mask_offset = str_pos + 1;
15742
15743 continue;
15744 }
15745 }
15746
15747 // reset the offset
15748
15749 mask_offset = 0;
15750
15751 mask[str_pos] = '\0';
15752
15753 switch (separator_cnt)
15754 {
15755 case 0:
15756 mp_reset_usr (mp_usr, 0);
15757
15758 custom_charset_1 = mask;
15759 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15760 break;
15761
15762 case 1:
15763 mp_reset_usr (mp_usr, 1);
15764
15765 custom_charset_2 = mask;
15766 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15767 break;
15768
15769 case 2:
15770 mp_reset_usr (mp_usr, 2);
15771
15772 custom_charset_3 = mask;
15773 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15774 break;
15775
15776 case 3:
15777 mp_reset_usr (mp_usr, 3);
15778
15779 custom_charset_4 = mask;
15780 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15781 break;
15782 }
15783
15784 mask = mask + str_pos + 1;
15785 }
15786 }
15787
15788 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15789 {
15790 if (maskpos > 0)
15791 {
15792 local_free (css_buf);
15793 local_free (data.root_css_buf);
15794 local_free (data.markov_css_buf);
15795
15796 local_free (masks[maskpos - 1]);
15797 }
15798
15799 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15800
15801 data.mask = mask;
15802 data.css_cnt = css_cnt;
15803 data.css_buf = css_buf;
15804
15805 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15806
15807 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15808
15809 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15810 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15811
15812 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15813
15814 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15815
15816 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15817 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15818
15819 data.root_css_buf = root_css_buf;
15820 data.markov_css_buf = markov_css_buf;
15821
15822 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15823
15824 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15825
15826 local_free (root_table_buf);
15827 local_free (markov_table_buf);
15828
15829 // args
15830
15831 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15832 {
15833 hc_device_param_t *device_param = &data.devices_param[device_id];
15834
15835 if (device_param->skipped) continue;
15836
15837 device_param->kernel_params_mp[0] = &device_param->d_combs;
15838 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15839 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15840
15841 device_param->kernel_params_mp_buf64[3] = 0;
15842 device_param->kernel_params_mp_buf32[4] = css_cnt;
15843 device_param->kernel_params_mp_buf32[5] = 0;
15844 device_param->kernel_params_mp_buf32[6] = 0;
15845 device_param->kernel_params_mp_buf32[7] = 0;
15846
15847 if (attack_mode == ATTACK_MODE_HYBRID1)
15848 {
15849 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15850 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15851 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15852 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15853 }
15854 else if (attack_mode == ATTACK_MODE_HYBRID2)
15855 {
15856 device_param->kernel_params_mp_buf32[5] = 0;
15857 device_param->kernel_params_mp_buf32[6] = 0;
15858 device_param->kernel_params_mp_buf32[7] = 0;
15859 }
15860
15861 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]);
15862 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]);
15863 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]);
15864
15865 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);
15866 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);
15867 }
15868 }
15869 else if (attack_mode == ATTACK_MODE_BF)
15870 {
15871 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15872
15873 if (increment)
15874 {
15875 for (uint i = 0; i < dictcnt; i++)
15876 {
15877 local_free (dictfiles[i]);
15878 }
15879
15880 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15881 {
15882 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15883
15884 if (l1_filename == NULL) break;
15885
15886 dictcnt++;
15887
15888 dictfiles[dictcnt - 1] = l1_filename;
15889 }
15890 }
15891 else
15892 {
15893 dictcnt++;
15894
15895 dictfiles[dictcnt - 1] = mask;
15896 }
15897
15898 if (dictcnt == 0)
15899 {
15900 log_error ("ERROR: Mask is too small");
15901
15902 return (-1);
15903 }
15904 }
15905 }
15906
15907 free (induction_dictionaries);
15908
15909 // induction_dictionaries_cnt = 0; // implied
15910
15911 if (attack_mode != ATTACK_MODE_BF)
15912 {
15913 if (keyspace == 0)
15914 {
15915 induction_dictionaries = scan_directory (induction_directory);
15916
15917 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15918 }
15919 }
15920
15921 if (induction_dictionaries_cnt)
15922 {
15923 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15924 }
15925
15926 /**
15927 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15928 */
15929 if (keyspace == 1)
15930 {
15931 if ((maskcnt > 1) || (dictcnt > 1))
15932 {
15933 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15934
15935 return (-1);
15936 }
15937 }
15938
15939 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15940 {
15941 char *subid = logfile_generate_subid ();
15942
15943 data.subid = subid;
15944
15945 logfile_sub_msg ("START");
15946
15947 data.devices_status = STATUS_INIT;
15948
15949 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
15950 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
15951 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
15952
15953 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15954
15955 data.cpt_pos = 0;
15956
15957 data.cpt_start = time (NULL);
15958
15959 data.cpt_total = 0;
15960
15961 if (data.restore == 0)
15962 {
15963 rd->words_cur = skip;
15964
15965 skip = 0;
15966
15967 data.skip = 0;
15968 }
15969
15970 data.ms_paused = 0;
15971
15972 data.words_cur = rd->words_cur;
15973
15974 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15975 {
15976 hc_device_param_t *device_param = &data.devices_param[device_id];
15977
15978 if (device_param->skipped) continue;
15979
15980 device_param->speed_pos = 0;
15981
15982 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
15983 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
15984 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
15985
15986 device_param->exec_pos = 0;
15987
15988 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
15989
15990 device_param->kernel_power = device_param->kernel_power_user;
15991
15992 device_param->outerloop_pos = 0;
15993 device_param->outerloop_left = 0;
15994 device_param->innerloop_pos = 0;
15995 device_param->innerloop_left = 0;
15996
15997 // some more resets:
15998
15999 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
16000
16001 device_param->pws_cnt = 0;
16002
16003 device_param->words_off = 0;
16004 device_param->words_done = 0;
16005 }
16006
16007 data.kernel_power_div = 0;
16008
16009 // figure out some workload
16010
16011 if (attack_mode == ATTACK_MODE_STRAIGHT)
16012 {
16013 if (data.wordlist_mode == WL_MODE_FILE)
16014 {
16015 char *dictfile = NULL;
16016
16017 if (induction_dictionaries_cnt)
16018 {
16019 dictfile = induction_dictionaries[0];
16020 }
16021 else
16022 {
16023 dictfile = dictfiles[dictpos];
16024 }
16025
16026 data.dictfile = dictfile;
16027
16028 logfile_sub_string (dictfile);
16029
16030 for (uint i = 0; i < rp_files_cnt; i++)
16031 {
16032 logfile_sub_var_string ("rulefile", rp_files[i]);
16033 }
16034
16035 FILE *fd2 = fopen (dictfile, "rb");
16036
16037 if (fd2 == NULL)
16038 {
16039 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16040
16041 return (-1);
16042 }
16043
16044 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16045
16046 fclose (fd2);
16047
16048 if (data.words_cnt == 0)
16049 {
16050 if (data.devices_status == STATUS_CRACKED) break;
16051 if (data.devices_status == STATUS_ABORTED) break;
16052
16053 dictpos++;
16054
16055 continue;
16056 }
16057 }
16058 }
16059 else if (attack_mode == ATTACK_MODE_COMBI)
16060 {
16061 char *dictfile = data.dictfile;
16062 char *dictfile2 = data.dictfile2;
16063
16064 logfile_sub_string (dictfile);
16065 logfile_sub_string (dictfile2);
16066
16067 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
16068 {
16069 FILE *fd2 = fopen (dictfile, "rb");
16070
16071 if (fd2 == NULL)
16072 {
16073 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16074
16075 return (-1);
16076 }
16077
16078 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16079
16080 fclose (fd2);
16081 }
16082 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
16083 {
16084 FILE *fd2 = fopen (dictfile2, "rb");
16085
16086 if (fd2 == NULL)
16087 {
16088 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16089
16090 return (-1);
16091 }
16092
16093 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
16094
16095 fclose (fd2);
16096 }
16097
16098 if (data.words_cnt == 0)
16099 {
16100 if (data.devices_status == STATUS_CRACKED) break;
16101 if (data.devices_status == STATUS_ABORTED) break;
16102
16103 dictpos++;
16104
16105 continue;
16106 }
16107 }
16108 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16109 {
16110 char *dictfile = NULL;
16111
16112 if (induction_dictionaries_cnt)
16113 {
16114 dictfile = induction_dictionaries[0];
16115 }
16116 else
16117 {
16118 dictfile = dictfiles[dictpos];
16119 }
16120
16121 data.dictfile = dictfile;
16122
16123 char *mask = data.mask;
16124
16125 logfile_sub_string (dictfile);
16126 logfile_sub_string (mask);
16127
16128 FILE *fd2 = fopen (dictfile, "rb");
16129
16130 if (fd2 == NULL)
16131 {
16132 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16133
16134 return (-1);
16135 }
16136
16137 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16138
16139 fclose (fd2);
16140
16141 if (data.words_cnt == 0)
16142 {
16143 if (data.devices_status == STATUS_CRACKED) break;
16144 if (data.devices_status == STATUS_ABORTED) break;
16145
16146 dictpos++;
16147
16148 continue;
16149 }
16150 }
16151 else if (attack_mode == ATTACK_MODE_BF)
16152 {
16153 local_free (css_buf);
16154 local_free (data.root_css_buf);
16155 local_free (data.markov_css_buf);
16156
16157 char *mask = dictfiles[dictpos];
16158
16159 logfile_sub_string (mask);
16160
16161 // base
16162
16163 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16164
16165 if (opts_type & OPTS_TYPE_PT_UNICODE)
16166 {
16167 uint css_cnt_unicode = css_cnt * 2;
16168
16169 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
16170
16171 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
16172 {
16173 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
16174
16175 css_buf_unicode[j + 1].cs_buf[0] = 0;
16176 css_buf_unicode[j + 1].cs_len = 1;
16177 }
16178
16179 free (css_buf);
16180
16181 css_buf = css_buf_unicode;
16182 css_cnt = css_cnt_unicode;
16183 }
16184
16185 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
16186
16187 uint mask_min = pw_min;
16188 uint mask_max = pw_max;
16189
16190 if (opts_type & OPTS_TYPE_PT_UNICODE)
16191 {
16192 mask_min *= 2;
16193 mask_max *= 2;
16194 }
16195
16196 if ((css_cnt < mask_min) || (css_cnt > mask_max))
16197 {
16198 if (css_cnt < mask_min)
16199 {
16200 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
16201 }
16202
16203 if (css_cnt > mask_max)
16204 {
16205 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
16206 }
16207
16208 // skip to next mask
16209
16210 dictpos++;
16211
16212 rd->dictpos = dictpos;
16213
16214 logfile_sub_msg ("STOP");
16215
16216 continue;
16217 }
16218
16219 uint save_css_cnt = css_cnt;
16220
16221 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16222 {
16223 if (opti_type & OPTI_TYPE_APPENDED_SALT)
16224 {
16225 uint salt_len = (uint) data.salts_buf[0].salt_len;
16226 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
16227
16228 uint css_cnt_salt = css_cnt + salt_len;
16229
16230 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
16231
16232 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
16233
16234 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
16235 {
16236 css_buf_salt[j].cs_buf[0] = salt_buf[i];
16237 css_buf_salt[j].cs_len = 1;
16238 }
16239
16240 free (css_buf);
16241
16242 css_buf = css_buf_salt;
16243 css_cnt = css_cnt_salt;
16244 }
16245 }
16246
16247 data.mask = mask;
16248 data.css_cnt = css_cnt;
16249 data.css_buf = css_buf;
16250
16251 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
16252
16253 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16254
16255 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16256
16257 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16258 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16259
16260 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16261
16262 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16263
16264 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16265 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16266
16267 data.root_css_buf = root_css_buf;
16268 data.markov_css_buf = markov_css_buf;
16269
16270 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16271
16272 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16273
16274 local_free (root_table_buf);
16275 local_free (markov_table_buf);
16276
16277 // copy + args
16278
16279 uint css_cnt_l = css_cnt;
16280 uint css_cnt_r;
16281
16282 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16283 {
16284 if (save_css_cnt < 6)
16285 {
16286 css_cnt_r = 1;
16287 }
16288 else if (save_css_cnt == 6)
16289 {
16290 css_cnt_r = 2;
16291 }
16292 else
16293 {
16294 if (opts_type & OPTS_TYPE_PT_UNICODE)
16295 {
16296 if (save_css_cnt == 8 || save_css_cnt == 10)
16297 {
16298 css_cnt_r = 2;
16299 }
16300 else
16301 {
16302 css_cnt_r = 4;
16303 }
16304 }
16305 else
16306 {
16307 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
16308 {
16309 css_cnt_r = 3;
16310 }
16311 else
16312 {
16313 css_cnt_r = 4;
16314 }
16315 }
16316 }
16317 }
16318 else
16319 {
16320 css_cnt_r = 1;
16321
16322 /* unfinished code?
16323 int sum = css_buf[css_cnt_r - 1].cs_len;
16324
16325 for (uint i = 1; i < 4 && i < css_cnt; i++)
16326 {
16327 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
16328
16329 css_cnt_r++;
16330
16331 sum *= css_buf[css_cnt_r - 1].cs_len;
16332 }
16333 */
16334 }
16335
16336 css_cnt_l -= css_cnt_r;
16337
16338 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
16339
16340 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16341 {
16342 hc_device_param_t *device_param = &data.devices_param[device_id];
16343
16344 if (device_param->skipped) continue;
16345
16346 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
16347 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
16348 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
16349
16350 device_param->kernel_params_mp_l_buf64[3] = 0;
16351 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
16352 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
16353 device_param->kernel_params_mp_l_buf32[6] = 0;
16354 device_param->kernel_params_mp_l_buf32[7] = 0;
16355 device_param->kernel_params_mp_l_buf32[8] = 0;
16356
16357 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
16358 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
16359 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
16360 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
16361
16362 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
16363 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
16364 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
16365
16366 device_param->kernel_params_mp_r_buf64[3] = 0;
16367 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
16368 device_param->kernel_params_mp_r_buf32[5] = 0;
16369 device_param->kernel_params_mp_r_buf32[6] = 0;
16370 device_param->kernel_params_mp_r_buf32[7] = 0;
16371
16372 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]);
16373 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]);
16374 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]);
16375
16376 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]);
16377 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]);
16378 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]);
16379
16380 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);
16381 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);
16382 }
16383 }
16384
16385 u64 words_base = data.words_cnt;
16386
16387 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16388 {
16389 if (data.kernel_rules_cnt)
16390 {
16391 words_base /= data.kernel_rules_cnt;
16392 }
16393 }
16394 else if (data.attack_kern == ATTACK_KERN_COMBI)
16395 {
16396 if (data.combs_cnt)
16397 {
16398 words_base /= data.combs_cnt;
16399 }
16400 }
16401 else if (data.attack_kern == ATTACK_KERN_BF)
16402 {
16403 if (data.bfs_cnt)
16404 {
16405 words_base /= data.bfs_cnt;
16406 }
16407 }
16408
16409 data.words_base = words_base;
16410
16411 if (keyspace == 1)
16412 {
16413 log_info ("%llu", (unsigned long long int) words_base);
16414
16415 return (0);
16416 }
16417
16418 if (data.words_cur > data.words_base)
16419 {
16420 log_error ("ERROR: restore value greater keyspace");
16421
16422 return (-1);
16423 }
16424
16425 if (data.words_cur)
16426 {
16427 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16428 {
16429 for (uint i = 0; i < data.salts_cnt; i++)
16430 {
16431 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16432 }
16433 }
16434 else if (data.attack_kern == ATTACK_KERN_COMBI)
16435 {
16436 for (uint i = 0; i < data.salts_cnt; i++)
16437 {
16438 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16439 }
16440 }
16441 else if (data.attack_kern == ATTACK_KERN_BF)
16442 {
16443 for (uint i = 0; i < data.salts_cnt; i++)
16444 {
16445 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16446 }
16447 }
16448 }
16449
16450 /*
16451 * Inform user about possible slow speeds
16452 */
16453
16454 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16455 {
16456 if (data.words_base < kernel_power_all)
16457 {
16458 if (quiet == 0)
16459 {
16460 log_info ("");
16461 log_info ("ATTENTION!");
16462 log_info (" The wordlist or mask you are using is too small.");
16463 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
16464 log_info (" The cracking speed will drop.");
16465 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16466 log_info ("");
16467 }
16468 }
16469 }
16470
16471 /*
16472 * Update loopback file
16473 */
16474
16475 if (loopback == 1)
16476 {
16477 time_t now;
16478
16479 time (&now);
16480
16481 uint random_num = get_random_num (0, 9999);
16482
16483 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16484
16485 data.loopback_file = loopback_file;
16486 }
16487
16488 /*
16489 * Update dictionary statistic
16490 */
16491
16492 if (keyspace == 0)
16493 {
16494 dictstat_fp = fopen (dictstat, "wb");
16495
16496 if (dictstat_fp)
16497 {
16498 lock_file (dictstat_fp);
16499
16500 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16501
16502 fclose (dictstat_fp);
16503 }
16504 }
16505
16506 data.devices_status = STATUS_RUNNING;
16507
16508 if (initial_restore_done == 0)
16509 {
16510 if (data.restore_disable == 0) cycle_restore ();
16511
16512 initial_restore_done = 1;
16513 }
16514
16515 hc_timer_set (&data.timer_running);
16516
16517 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16518 {
16519 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16520 {
16521 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16522 if (quiet == 0) fflush (stdout);
16523 }
16524 }
16525 else if (wordlist_mode == WL_MODE_STDIN)
16526 {
16527 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16528 if (data.quiet == 0) log_info ("");
16529 }
16530
16531 time_t runtime_start;
16532
16533 time (&runtime_start);
16534
16535 data.runtime_start = runtime_start;
16536
16537 /**
16538 * create cracker threads
16539 */
16540
16541 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
16542
16543 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16544 {
16545 hc_device_param_t *device_param = &devices_param[device_id];
16546
16547 if (wordlist_mode == WL_MODE_STDIN)
16548 {
16549 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16550 }
16551 else
16552 {
16553 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16554 }
16555 }
16556
16557 // wait for crack threads to exit
16558
16559 hc_thread_wait (data.devices_cnt, c_threads);
16560
16561 local_free (c_threads);
16562
16563 data.restore = 0;
16564
16565 // finalize task
16566
16567 logfile_sub_var_uint ("status-after-work", data.devices_status);
16568
16569 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16570
16571 if (data.devices_status == STATUS_CRACKED) break;
16572 if (data.devices_status == STATUS_ABORTED) break;
16573
16574 if (data.devices_status == STATUS_BYPASS)
16575 {
16576 data.devices_status = STATUS_RUNNING;
16577 }
16578
16579 if (induction_dictionaries_cnt)
16580 {
16581 unlink (induction_dictionaries[0]);
16582 }
16583
16584 free (induction_dictionaries);
16585
16586 if (attack_mode != ATTACK_MODE_BF)
16587 {
16588 induction_dictionaries = scan_directory (induction_directory);
16589
16590 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16591 }
16592
16593 if (benchmark == 0)
16594 {
16595 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16596 {
16597 if (quiet == 0) clear_prompt ();
16598
16599 if (quiet == 0) log_info ("");
16600
16601 if (status == 1)
16602 {
16603 status_display ();
16604 }
16605 else
16606 {
16607 if (quiet == 0) status_display ();
16608 }
16609
16610 if (quiet == 0) log_info ("");
16611 }
16612 }
16613
16614 if (attack_mode == ATTACK_MODE_BF)
16615 {
16616 dictpos++;
16617
16618 rd->dictpos = dictpos;
16619 }
16620 else
16621 {
16622 if (induction_dictionaries_cnt)
16623 {
16624 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16625 }
16626 else
16627 {
16628 dictpos++;
16629
16630 rd->dictpos = dictpos;
16631 }
16632 }
16633
16634 time_t runtime_stop;
16635
16636 time (&runtime_stop);
16637
16638 data.runtime_stop = runtime_stop;
16639
16640 logfile_sub_uint (runtime_start);
16641 logfile_sub_uint (runtime_stop);
16642
16643 logfile_sub_msg ("STOP");
16644
16645 global_free (subid);
16646 }
16647
16648 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16649
16650 if (data.devices_status == STATUS_CRACKED) break;
16651 if (data.devices_status == STATUS_ABORTED) break;
16652 if (data.devices_status == STATUS_QUIT) break;
16653
16654 if (data.devices_status == STATUS_BYPASS)
16655 {
16656 data.devices_status = STATUS_RUNNING;
16657 }
16658 }
16659
16660 // 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
16661
16662 if (attack_mode == ATTACK_MODE_STRAIGHT)
16663 {
16664 if (data.wordlist_mode == WL_MODE_FILE)
16665 {
16666 if (data.dictfile == NULL)
16667 {
16668 if (dictfiles != NULL)
16669 {
16670 data.dictfile = dictfiles[0];
16671
16672 hc_timer_set (&data.timer_running);
16673 }
16674 }
16675 }
16676 }
16677 // NOTE: combi is okay because it is already set beforehand
16678 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16679 {
16680 if (data.dictfile == NULL)
16681 {
16682 if (dictfiles != NULL)
16683 {
16684 hc_timer_set (&data.timer_running);
16685
16686 data.dictfile = dictfiles[0];
16687 }
16688 }
16689 }
16690 else if (attack_mode == ATTACK_MODE_BF)
16691 {
16692 if (data.mask == NULL)
16693 {
16694 hc_timer_set (&data.timer_running);
16695
16696 data.mask = masks[0];
16697 }
16698 }
16699
16700 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16701 {
16702 data.devices_status = STATUS_EXHAUSTED;
16703 }
16704
16705 // if cracked / aborted remove last induction dictionary
16706
16707 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16708 {
16709 struct stat induct_stat;
16710
16711 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16712 {
16713 unlink (induction_dictionaries[file_pos]);
16714 }
16715 }
16716
16717 // wait for non-interactive threads
16718
16719 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16720 {
16721 hc_thread_wait (1, &ni_threads[thread_idx]);
16722 }
16723
16724 local_free (ni_threads);
16725
16726 // wait for interactive threads
16727
16728 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16729 {
16730 hc_thread_wait (1, &i_thread);
16731 }
16732
16733 // we dont need restore file anymore
16734 if (data.restore_disable == 0)
16735 {
16736 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16737 {
16738 unlink (eff_restore_file);
16739 unlink (new_restore_file);
16740 }
16741 else
16742 {
16743 cycle_restore ();
16744 }
16745 }
16746
16747 // finally save left hashes
16748
16749 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16750 {
16751 save_hash ();
16752 }
16753
16754 /**
16755 * Clean up
16756 */
16757
16758 if (benchmark == 1)
16759 {
16760 status_benchmark ();
16761
16762 log_info ("");
16763 }
16764 else
16765 {
16766 if (quiet == 0) clear_prompt ();
16767
16768 if (quiet == 0) log_info ("");
16769
16770 if (status == 1)
16771 {
16772 status_display ();
16773 }
16774 else
16775 {
16776 if (quiet == 0) status_display ();
16777 }
16778
16779 if (quiet == 0) log_info ("");
16780 }
16781
16782 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16783 {
16784 hc_device_param_t *device_param = &data.devices_param[device_id];
16785
16786 if (device_param->skipped) continue;
16787
16788 local_free (device_param->result);
16789
16790 local_free (device_param->combs_buf);
16791
16792 local_free (device_param->hooks_buf);
16793
16794 local_free (device_param->device_name);
16795
16796 local_free (device_param->device_name_chksum);
16797
16798 local_free (device_param->device_version);
16799
16800 local_free (device_param->driver_version);
16801
16802 if (device_param->pws_buf) myfree (device_param->pws_buf);
16803 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
16804 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
16805 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
16806 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
16807 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
16808 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
16809 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
16810 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
16811 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
16812 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
16813 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
16814 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
16815 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
16816 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
16817 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
16818 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
16819 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
16820 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
16821 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
16822 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
16823 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
16824 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
16825 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
16826 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
16827 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
16828 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
16829 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
16830 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
16831
16832 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
16833 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
16834 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
16835 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
16836 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
16837 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
16838 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
16839 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
16840 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
16841 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
16842
16843 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
16844 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
16845 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
16846
16847 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
16848 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
16849 }
16850
16851 // reset default fan speed
16852
16853 #ifdef HAVE_HWMON
16854 if (gpu_temp_disable == 0)
16855 {
16856 #ifdef HAVE_ADL
16857 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16858 {
16859 hc_thread_mutex_lock (mux_adl);
16860
16861 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16862 {
16863 hc_device_param_t *device_param = &data.devices_param[device_id];
16864
16865 if (device_param->skipped) continue;
16866
16867 if (data.hm_device[device_id].fan_supported == 1)
16868 {
16869 int fanspeed = temp_retain_fanspeed_value[device_id];
16870
16871 if (fanspeed == -1) continue;
16872
16873 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
16874
16875 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
16876 }
16877 }
16878
16879 hc_thread_mutex_unlock (mux_adl);
16880 }
16881 #endif // HAVE_ADL
16882 }
16883
16884 #ifdef HAVE_ADL
16885 // reset power tuning
16886
16887 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16888 {
16889 hc_thread_mutex_lock (mux_adl);
16890
16891 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16892 {
16893 hc_device_param_t *device_param = &data.devices_param[device_id];
16894
16895 if (device_param->skipped) continue;
16896
16897 if (data.hm_device[device_id].od_version == 6)
16898 {
16899 // check powertune capabilities first, if not available then skip device
16900
16901 int powertune_supported = 0;
16902
16903 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
16904 {
16905 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16906
16907 return (-1);
16908 }
16909
16910 if (powertune_supported != 0)
16911 {
16912 // powercontrol settings
16913
16914 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)
16915 {
16916 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16917
16918 return (-1);
16919 }
16920
16921 // clocks
16922
16923 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16924
16925 performance_state->iNumberOfPerformanceLevels = 2;
16926
16927 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
16928 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
16929 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
16930 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
16931
16932 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)
16933 {
16934 log_info ("ERROR: Failed to restore ADL performance state");
16935
16936 return (-1);
16937 }
16938
16939 local_free (performance_state);
16940 }
16941 }
16942 }
16943
16944 hc_thread_mutex_unlock (mux_adl);
16945 }
16946 #endif // HAVE_ADL
16947
16948 if (gpu_temp_disable == 0)
16949 {
16950 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
16951 if (data.hm_nv)
16952 {
16953 #if defined(LINUX) && defined(HAVE_NVML)
16954
16955 hm_NVML_nvmlShutdown (data.hm_nv);
16956
16957 nvml_close (data.hm_nv);
16958
16959 #elif defined(WIN) && (HAVE_NVAPI)
16960
16961 hm_NvAPI_Unload (data.hm_nv);
16962
16963 nvapi_close (data.hm_nv);
16964
16965 #endif
16966
16967 data.hm_nv = NULL;
16968 }
16969 #endif
16970
16971 #ifdef HAVE_ADL
16972 if (data.hm_amd)
16973 {
16974 hm_ADL_Main_Control_Destroy (data.hm_amd);
16975
16976 adl_close (data.hm_amd);
16977 data.hm_amd = NULL;
16978 }
16979 #endif
16980 }
16981 #endif // HAVE_HWMON
16982
16983 // free memory
16984
16985 local_free (masks);
16986
16987 local_free (dictstat_base);
16988
16989 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
16990 {
16991 pot_t *pot_ptr = &pot[pot_pos];
16992
16993 hash_t *hash = &pot_ptr->hash;
16994
16995 local_free (hash->digest);
16996
16997 if (isSalted)
16998 {
16999 local_free (hash->salt);
17000 }
17001 }
17002
17003 local_free (pot);
17004
17005 local_free (all_kernel_rules_cnt);
17006 local_free (all_kernel_rules_buf);
17007
17008 local_free (wl_data->buf);
17009 local_free (wl_data);
17010
17011 local_free (bitmap_s1_a);
17012 local_free (bitmap_s1_b);
17013 local_free (bitmap_s1_c);
17014 local_free (bitmap_s1_d);
17015 local_free (bitmap_s2_a);
17016 local_free (bitmap_s2_b);
17017 local_free (bitmap_s2_c);
17018 local_free (bitmap_s2_d);
17019
17020 #ifdef HAVE_HWMON
17021 local_free (temp_retain_fanspeed_value);
17022 #ifdef HAVE_ADL
17023 local_free (od_clock_mem_status);
17024 local_free (od_power_control_status);
17025 #endif // ADL
17026 #endif
17027
17028 global_free (devices_param);
17029
17030 global_free (kernel_rules_buf);
17031
17032 global_free (root_css_buf);
17033 global_free (markov_css_buf);
17034
17035 global_free (digests_buf);
17036 global_free (digests_shown);
17037 global_free (digests_shown_tmp);
17038
17039 global_free (salts_buf);
17040 global_free (salts_shown);
17041
17042 global_free (esalts_buf);
17043
17044 global_free (words_progress_done);
17045 global_free (words_progress_rejected);
17046 global_free (words_progress_restored);
17047
17048 if (pot_fp) fclose (pot_fp);
17049
17050 if (data.devices_status == STATUS_QUIT) break;
17051 }
17052
17053 // destroy others mutex
17054
17055 hc_thread_mutex_delete (mux_dispatcher);
17056 hc_thread_mutex_delete (mux_counter);
17057 hc_thread_mutex_delete (mux_display);
17058 hc_thread_mutex_delete (mux_adl);
17059
17060 // free memory
17061
17062 local_free (eff_restore_file);
17063 local_free (new_restore_file);
17064
17065 local_free (rd);
17066
17067 // tuning db
17068
17069 tuning_db_destroy (tuning_db);
17070
17071 // loopback
17072
17073 local_free (loopback_file);
17074
17075 if (loopback == 1) unlink (loopback_file);
17076
17077 // induction directory
17078
17079 if (induction_dir == NULL)
17080 {
17081 if (attack_mode != ATTACK_MODE_BF)
17082 {
17083 if (rmdir (induction_directory) == -1)
17084 {
17085 if (errno == ENOENT)
17086 {
17087 // good, we can ignore
17088 }
17089 else if (errno == ENOTEMPTY)
17090 {
17091 // good, we can ignore
17092 }
17093 else
17094 {
17095 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
17096
17097 return (-1);
17098 }
17099 }
17100
17101 local_free (induction_directory);
17102 }
17103 }
17104
17105 // outfile-check directory
17106
17107 if (outfile_check_dir == NULL)
17108 {
17109 if (rmdir (outfile_check_directory) == -1)
17110 {
17111 if (errno == ENOENT)
17112 {
17113 // good, we can ignore
17114 }
17115 else if (errno == ENOTEMPTY)
17116 {
17117 // good, we can ignore
17118 }
17119 else
17120 {
17121 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
17122
17123 return (-1);
17124 }
17125 }
17126
17127 local_free (outfile_check_directory);
17128 }
17129
17130 time_t proc_stop;
17131
17132 time (&proc_stop);
17133
17134 logfile_top_uint (proc_start);
17135 logfile_top_uint (proc_stop);
17136
17137 logfile_top_msg ("STOP");
17138
17139 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
17140 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
17141
17142 if (data.ocl) ocl_close (data.ocl);
17143
17144 if (data.devices_status == STATUS_ABORTED) return 2;
17145 if (data.devices_status == STATUS_QUIT) return 2;
17146 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
17147 if (data.devices_status == STATUS_EXHAUSTED) return 1;
17148 if (data.devices_status == STATUS_CRACKED) return 0;
17149
17150 return -1;
17151 }
Hashcat additions to support pwdhash