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