projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
show a warning if hlfmt_hash () fails
[hashcat.git] / src / oclHashcat.c
1 /**
2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
5 *
6 * License.....: MIT
7 */
8
9 #ifdef OSX
10 #include <stdio.h>
11 #endif
12
13 #include <common.h>
14 #include <shared.h>
15 #include <rp_kernel_on_cpu.h>
16 #include <getopt.h>
17
18 const char *PROGNAME = "oclHashcat";
19 const uint VERSION_BIN = 210;
20 const uint RESTORE_MIN = 210;
21
22 double TARGET_MS_PROFILE[3] = { 8, 16, 96 };
23
24 #define INCR_RULES 10000
25 #define INCR_SALTS 100000
26 #define INCR_MASKS 1000
27 #define INCR_POT 1000
28
29 #define USAGE 0
30 #define VERSION 0
31 #define QUIET 0
32 #define MARKOV_THRESHOLD 0
33 #define MARKOV_DISABLE 0
34 #define MARKOV_CLASSIC 0
35 #define BENCHMARK 0
36 #define BENCHMARK_REPEATS 2
37 #define RESTORE 0
38 #define RESTORE_TIMER 60
39 #define RESTORE_DISABLE 0
40 #define STATUS 0
41 #define STATUS_TIMER 10
42 #define STATUS_AUTOMAT 0
43 #define LOOPBACK 0
44 #define WEAK_HASH_THRESHOLD 100
45 #define SHOW 0
46 #define LEFT 0
47 #define USERNAME 0
48 #define REMOVE 0
49 #define REMOVE_TIMER 60
50 #define SKIP 0
51 #define LIMIT 0
52 #define KEYSPACE 0
53 #define POTFILE_DISABLE 0
54 #define DEBUG_MODE 0
55 #define RP_GEN 0
56 #define RP_GEN_FUNC_MIN 1
57 #define RP_GEN_FUNC_MAX 4
58 #define RP_GEN_SEED 0
59 #define RULE_BUF_L ":"
60 #define RULE_BUF_R ":"
61 #define FORCE 0
62 #define RUNTIME 0
63 #define HEX_CHARSET 0
64 #define HEX_SALT 0
65 #define HEX_WORDLIST 0
66 #define OUTFILE_FORMAT 3
67 #define OUTFILE_AUTOHEX 1
68 #define OUTFILE_CHECK_TIMER 5
69 #define ATTACK_MODE 0
70 #define HASH_MODE 0
71 #define SEGMENT_SIZE 32
72 #define INCREMENT 0
73 #define INCREMENT_MIN 1
74 #define INCREMENT_MAX PW_MAX
75 #define SEPARATOR ':'
76 #define BITMAP_MIN 16
77 #define BITMAP_MAX 24
78 #define GPU_TEMP_DISABLE 0
79 #define GPU_TEMP_ABORT 90
80 #define GPU_TEMP_RETAIN 80
81 #define WORKLOAD_PROFILE 2
82 #define KERNEL_ACCEL 0
83 #define KERNEL_LOOPS 0
84 #define KERNEL_RULES 1024
85 #define KERNEL_COMBS 1024
86 #define KERNEL_BFS 1024
87 #define KERNEL_THREADS 64
88 #define POWERTUNE_ENABLE 0
89 #define LOGFILE_DISABLE 0
90 #define SCRYPT_TMTO 0
91 #define OPENCL_VECTOR_WIDTH 0
92
93 #define WL_MODE_STDIN 1
94 #define WL_MODE_FILE 2
95 #define WL_MODE_MASK 3
96
97 #define HL_MODE_FILE 4
98 #define HL_MODE_ARG 5
99
100 #define HLFMTS_CNT 11
101 #define HLFMT_HASHCAT 0
102 #define HLFMT_PWDUMP 1
103 #define HLFMT_PASSWD 2
104 #define HLFMT_SHADOW 3
105 #define HLFMT_DCC 4
106 #define HLFMT_DCC2 5
107 #define HLFMT_NETNTLM1 7
108 #define HLFMT_NETNTLM2 8
109 #define HLFMT_NSLDAP 9
110 #define HLFMT_NSLDAPS 10
111
112 #define HLFMT_TEXT_HASHCAT "native hashcat"
113 #define HLFMT_TEXT_PWDUMP "pwdump"
114 #define HLFMT_TEXT_PASSWD "passwd"
115 #define HLFMT_TEXT_SHADOW "shadow"
116 #define HLFMT_TEXT_DCC "DCC"
117 #define HLFMT_TEXT_DCC2 "DCC 2"
118 #define HLFMT_TEXT_NETNTLM1 "NetNTLMv1"
119 #define HLFMT_TEXT_NETNTLM2 "NetNTLMv2"
120 #define HLFMT_TEXT_NSLDAP "nsldap"
121 #define HLFMT_TEXT_NSLDAPS "nsldaps"
122
123 #define ATTACK_MODE_STRAIGHT 0
124 #define ATTACK_MODE_COMBI 1
125 #define ATTACK_MODE_TOGGLE 2
126 #define ATTACK_MODE_BF 3
127 #define ATTACK_MODE_PERM 4
128 #define ATTACK_MODE_TABLE 5
129 #define ATTACK_MODE_HYBRID1 6
130 #define ATTACK_MODE_HYBRID2 7
131 #define ATTACK_MODE_NONE 100
132
133 #define ATTACK_KERN_STRAIGHT 0
134 #define ATTACK_KERN_COMBI 1
135 #define ATTACK_KERN_BF 3
136 #define ATTACK_KERN_NONE 100
137
138 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
139 #define ATTACK_EXEC_INSIDE_KERNEL 11
140
141 #define COMBINATOR_MODE_BASE_LEFT 10001
142 #define COMBINATOR_MODE_BASE_RIGHT 10002
143
144 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
145 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
146
147 #define MAX_CUT_TRIES 4
148
149 #define MAX_DICTSTAT 10000
150
151 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 133
152
153 #define global_free(attr) \
154 { \
155 myfree ((void *) data.attr); \
156 \
157 data.attr = NULL; \
158 }
159
160 #define local_free(attr) \
161 { \
162 myfree ((void *) attr); \
163 \
164 attr = NULL; \
165 }
166
167 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
168 {
169 900,
170 0,
171 5100,
172 100,
173 1400,
174 10800,
175 1700,
176 5000,
177 10100,
178 6000,
179 6100,
180 6900,
181 11700,
182 11800,
183 400,
184 8900,
185 11900,
186 12000,
187 10900,
188 12100,
189 23,
190 2500,
191 5300,
192 5400,
193 5500,
194 5600,
195 7300,
196 7500,
197 13100,
198 8300,
199 11100,
200 11200,
201 11400,
202 121,
203 2611,
204 2711,
205 2811,
206 8400,
207 11,
208 2612,
209 7900,
210 21,
211 11000,
212 124,
213 10000,
214 3711,
215 7600,
216 12,
217 131,
218 132,
219 1731,
220 200,
221 300,
222 3100,
223 112,
224 12300,
225 8000,
226 141,
227 1441,
228 1600,
229 12600,
230 1421,
231 101,
232 111,
233 1711,
234 3000,
235 1000,
236 1100,
237 2100,
238 12800,
239 1500,
240 12400,
241 500,
242 3200,
243 7400,
244 1800,
245 122,
246 1722,
247 7100,
248 6300,
249 6700,
250 6400,
251 6500,
252 2400,
253 2410,
254 5700,
255 9200,
256 9300,
257 22,
258 501,
259 5800,
260 8100,
261 8500,
262 7200,
263 9900,
264 7700,
265 7800,
266 10300,
267 8600,
268 8700,
269 9100,
270 133,
271 11600,
272 12500,
273 13000,
274 13200,
275 13300,
276 6211,
277 6221,
278 6231,
279 6241,
280 8800,
281 12900,
282 12200,
283 9700,
284 9710,
285 9800,
286 9810,
287 9400,
288 9500,
289 9600,
290 10400,
291 10410,
292 10500,
293 10600,
294 10700,
295 9000,
296 5200,
297 6800,
298 6600,
299 8200,
300 11300,
301 12700
302 };
303
304 /**
305 * types
306 */
307
308 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
309
310 /**
311 * globals
312 */
313
314 static unsigned int full01 = 0x01010101;
315 static unsigned int full80 = 0x80808080;
316
317 int SUPPRESS_OUTPUT = 0;
318
319 hc_thread_mutex_t mux_adl;
320 hc_thread_mutex_t mux_counter;
321 hc_thread_mutex_t mux_dispatcher;
322 hc_thread_mutex_t mux_display;
323
324 hc_global_data_t data;
325
326 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
327
328 const char *USAGE_MINI[] =
329 {
330 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
331 "",
332 "Try --help for more help.",
333 NULL
334 };
335
336 const char *USAGE_BIG[] =
337 {
338 "%s, advanced password recovery",
339 "",
340 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
341 "",
342 "=======",
343 "Options",
344 "=======",
345 "",
346 "* General:",
347 "",
348 " -m, --hash-type=NUM Hash-type, see references below",
349 " -a, --attack-mode=NUM Attack-mode, see references below",
350 " -V, --version Print version",
351 " -h, --help Print help",
352 " --quiet Suppress output",
353 "",
354 "* Misc:",
355 "",
356 " --hex-charset Assume charset is given in hex",
357 " --hex-salt Assume salt is given in hex",
358 " --hex-wordlist Assume words in wordlist is given in hex",
359 " --force Ignore warnings",
360 " --status Enable automatic update of the status-screen",
361 " --status-timer=NUM Seconds between status-screen update",
362 " --status-automat Display the status view in a machine readable format",
363 " --loopback Add new plains to induct directory",
364 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
365 "",
366 "* Markov:",
367 "",
368 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
369 " --markov-disable Disables markov-chains, emulates classic brute-force",
370 " --markov-classic Enables classic markov-chains, no per-position enhancement",
371 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
372 "",
373 "* Session:",
374 "",
375 " --runtime=NUM Abort session after NUM seconds of runtime",
376 " --session=STR Define specific session name",
377 " --restore Restore session from --session",
378 " --restore-disable Do not write restore file",
379 "",
380 "* Files:",
381 "",
382 " -o, --outfile=FILE Define outfile for recovered hash",
383 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
384 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
385 " --outfile-check-timer=NUM Seconds between outfile checks",
386 " -p, --separator=CHAR Separator char for hashlists and outfile",
387 " --show Show cracked passwords only",
388 " --left Show un-cracked passwords only",
389 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
390 " --remove Enable remove of hash once it is cracked",
391 " --remove-timer=NUM Update input hash file each NUM seconds",
392 " --potfile-disable Do not write potfile",
393 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
394 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
395 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
396 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
397 " --logfile-disable Disable the logfile",
398 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
399 "",
400 "* Resources:",
401 "",
402 " -b, --benchmark Run benchmark",
403 " --benchmark-repeats=NUM Repeat the kernel on the device NUM times to increase benchmark accuracy",
404 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
405 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
406 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
407 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
408 " --opencl-platforms=STR OpenCL platforms to use, separate with comma",
409 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
410 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
411 " --opencl-vector-width=NUM OpenCL vector-width (either 1, 2, 4, 8 or 16), overrides value from device query",
412 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
413 " -n, --kernel-accel=NUM Workload tuning, increase the outer-loop step size",
414 " -u, --kernel-loops=NUM Workload tuning, increase the inner-loop step size",
415 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
416 #ifdef HAVE_HWMON
417 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
418 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
419 #ifdef HAVE_ADL
420 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
421 #endif
422 #endif
423 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
424 "",
425 "* Distributed:",
426 "",
427 " -s, --skip=NUM Skip number of words",
428 " -l, --limit=NUM Limit number of words",
429 " --keyspace Show keyspace base:mod values and quit",
430 "",
431 "* Rules:",
432 "",
433 " -j, --rule-left=RULE Single rule applied to each word from left dict",
434 " -k, --rule-right=RULE Single rule applied to each word from right dict",
435 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
436 " -g, --generate-rules=NUM Generate NUM random rules",
437 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
438 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
439 " --generate-rules-seed=NUM Force RNG seed to NUM",
440 "",
441 "* Custom charsets:",
442 "",
443 " -1, --custom-charset1=CS User-defined charsets",
444 " -2, --custom-charset2=CS Example:",
445 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
446 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
447 "",
448 "* Increment:",
449 "",
450 " -i, --increment Enable increment mode",
451 " --increment-min=NUM Start incrementing at NUM",
452 " --increment-max=NUM Stop incrementing at NUM",
453 "",
454 "==========",
455 "References",
456 "==========",
457 "",
458 "* Workload Profile:",
459 "",
460 " 1 = Interactive performance profile, kernel execution runtime to 8ms, lower latency desktop, lower speed",
461 " 2 = Default performance profile, kernel execution runtime to 16ms, economic setting",
462 " 3 = Headless performance profile, kernel execution runtime to 96ms, higher latency desktop, higher speed",
463 "",
464 "* OpenCL device-types:",
465 "",
466 " 1 = CPU devices",
467 " 2 = GPU devices",
468 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
469 "",
470 "* Outfile Formats:",
471 "",
472 " 1 = hash[:salt]",
473 " 2 = plain",
474 " 3 = hash[:salt]:plain",
475 " 4 = hex_plain",
476 " 5 = hash[:salt]:hex_plain",
477 " 6 = plain:hex_plain",
478 " 7 = hash[:salt]:plain:hex_plain",
479 " 8 = crackpos",
480 " 9 = hash[:salt]:crackpos",
481 " 10 = plain:crackpos",
482 " 11 = hash[:salt]:plain:crackpos",
483 " 12 = hex_plain:crackpos",
484 " 13 = hash[:salt]:hex_plain:crackpos",
485 " 14 = plain:hex_plain:crackpos",
486 " 15 = hash[:salt]:plain:hex_plain:crackpos",
487 "",
488 "* Debug mode output formats (for hybrid mode only, by using rules):",
489 "",
490 " 1 = save finding rule",
491 " 2 = save original word",
492 " 3 = save original word and finding rule",
493 " 4 = save original word, finding rule and modified plain",
494 "",
495 "* Built-in charsets:",
496 "",
497 " ?l = abcdefghijklmnopqrstuvwxyz",
498 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
499 " ?d = 0123456789",
500 " ?s = !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
501 " ?a = ?l?u?d?s",
502 " ?b = 0x00 - 0xff",
503 "",
504 "* Attack modes:",
505 "",
506 " 0 = Straight",
507 " 1 = Combination",
508 " 3 = Brute-force",
509 " 6 = Hybrid dict + mask",
510 " 7 = Hybrid mask + dict",
511 "",
512 "* Hash types:",
513 "",
514 "[[ Roll-your-own: Raw Hashes ]]",
515 "",
516 " 900 = MD4",
517 " 0 = MD5",
518 " 5100 = Half MD5",
519 " 100 = SHA1",
520 " 10800 = SHA-384",
521 " 1400 = SHA-256",
522 " 1700 = SHA-512",
523 " 5000 = SHA-3(Keccak)",
524 " 10100 = SipHash",
525 " 6000 = RipeMD160",
526 " 6100 = Whirlpool",
527 " 6900 = GOST R 34.11-94",
528 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
529 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
530 "",
531 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
532 "",
533 " 10 = md5($pass.$salt)",
534 " 20 = md5($salt.$pass)",
535 " 30 = md5(unicode($pass).$salt)",
536 " 40 = md5($salt.unicode($pass))",
537 " 3800 = md5($salt.$pass.$salt)",
538 " 3710 = md5($salt.md5($pass))",
539 " 2600 = md5(md5($pass)",
540 " 4300 = md5(strtoupper(md5($pass)))",
541 " 4400 = md5(sha1($pass))",
542 " 110 = sha1($pass.$salt)",
543 " 120 = sha1($salt.$pass)",
544 " 130 = sha1(unicode($pass).$salt)",
545 " 140 = sha1($salt.unicode($pass))",
546 " 4500 = sha1(sha1($pass)",
547 " 4700 = sha1(md5($pass))",
548 " 4900 = sha1($salt.$pass.$salt)",
549 " 1410 = sha256($pass.$salt)",
550 " 1420 = sha256($salt.$pass)",
551 " 1430 = sha256(unicode($pass).$salt)",
552 " 1440 = sha256($salt.unicode($pass))",
553 " 1710 = sha512($pass.$salt)",
554 " 1720 = sha512($salt.$pass)",
555 " 1730 = sha512(unicode($pass).$salt)",
556 " 1740 = sha512($salt.unicode($pass))",
557 "",
558 "[[ Roll-your-own: Authenticated Hashes ]]",
559 "",
560 " 50 = HMAC-MD5 (key = $pass)",
561 " 60 = HMAC-MD5 (key = $salt)",
562 " 150 = HMAC-SHA1 (key = $pass)",
563 " 160 = HMAC-SHA1 (key = $salt)",
564 " 1450 = HMAC-SHA256 (key = $pass)",
565 " 1460 = HMAC-SHA256 (key = $salt)",
566 " 1750 = HMAC-SHA512 (key = $pass)",
567 " 1760 = HMAC-SHA512 (key = $salt)",
568 "",
569 "[[ Generic KDF ]]",
570 "",
571 " 400 = phpass",
572 " 8900 = scrypt",
573 " 11900 = PBKDF2-HMAC-MD5",
574 " 12000 = PBKDF2-HMAC-SHA1",
575 " 10900 = PBKDF2-HMAC-SHA256",
576 " 12100 = PBKDF2-HMAC-SHA512",
577 "",
578 "[[ Network protocols, Challenge-Response ]]",
579 "",
580 " 23 = Skype",
581 " 2500 = WPA/WPA2",
582 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
583 " 5300 = IKE-PSK MD5",
584 " 5400 = IKE-PSK SHA1",
585 " 5500 = NetNTLMv1",
586 " 5500 = NetNTLMv1 + ESS",
587 " 5600 = NetNTLMv2",
588 " 7300 = IPMI2 RAKP HMAC-SHA1",
589 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
590 " 8300 = DNSSEC (NSEC3)",
591 " 10200 = Cram MD5",
592 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
593 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
594 " 11400 = SIP digest authentication (MD5)",
595 " 13100 = Kerberos 5 TGS-REP etype 23",
596 "",
597 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
598 "",
599 " 121 = SMF (Simple Machines Forum)",
600 " 400 = phpBB3",
601 " 2611 = vBulletin < v3.8.5",
602 " 2711 = vBulletin > v3.8.5",
603 " 2811 = MyBB",
604 " 2811 = IPB (Invison Power Board)",
605 " 8400 = WBB3 (Woltlab Burning Board)",
606 " 11 = Joomla < 2.5.18",
607 " 400 = Joomla > 2.5.18",
608 " 400 = Wordpress",
609 " 2612 = PHPS",
610 " 7900 = Drupal7",
611 " 21 = osCommerce",
612 " 21 = xt:Commerce",
613 " 11000 = PrestaShop",
614 " 124 = Django (SHA-1)",
615 " 10000 = Django (PBKDF2-SHA256)",
616 " 3711 = Mediawiki B type",
617 " 7600 = Redmine",
618 "",
619 "[[ Database Server ]]",
620 "",
621 " 12 = PostgreSQL",
622 " 131 = MSSQL(2000)",
623 " 132 = MSSQL(2005)",
624 " 1731 = MSSQL(2012)",
625 " 1731 = MSSQL(2014)",
626 " 200 = MySQL323",
627 " 300 = MySQL4.1/MySQL5",
628 " 3100 = Oracle H: Type (Oracle 7+)",
629 " 112 = Oracle S: Type (Oracle 11+)",
630 " 12300 = Oracle T: Type (Oracle 12+)",
631 " 8000 = Sybase ASE",
632 "",
633 "[[ HTTP, SMTP, LDAP Server ]]",
634 "",
635 " 141 = EPiServer 6.x < v4",
636 " 1441 = EPiServer 6.x > v4",
637 " 1600 = Apache $apr1$",
638 " 12600 = ColdFusion 10+",
639 " 1421 = hMailServer",
640 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
641 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
642 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
643 "",
644 "[[ Checksums ]]",
645 "",
646 " 11500 = CRC32",
647 "",
648 "[[ Operating-Systems ]]",
649 "",
650 " 3000 = LM",
651 " 1000 = NTLM",
652 " 1100 = Domain Cached Credentials (DCC), MS Cache",
653 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
654 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
655 " 1500 = descrypt, DES(Unix), Traditional DES",
656 " 12400 = BSDiCrypt, Extended DES",
657 " 500 = md5crypt $1$, MD5(Unix)",
658 " 3200 = bcrypt $2*$, Blowfish(Unix)",
659 " 7400 = sha256crypt $5$, SHA256(Unix)",
660 " 1800 = sha512crypt $6$, SHA512(Unix)",
661 " 122 = OSX v10.4",
662 " 122 = OSX v10.5",
663 " 122 = OSX v10.6",
664 " 1722 = OSX v10.7",
665 " 7100 = OSX v10.8",
666 " 7100 = OSX v10.9",
667 " 7100 = OSX v10.10",
668 " 6300 = AIX {smd5}",
669 " 6700 = AIX {ssha1}",
670 " 6400 = AIX {ssha256}",
671 " 6500 = AIX {ssha512}",
672 " 2400 = Cisco-PIX",
673 " 2410 = Cisco-ASA",
674 " 500 = Cisco-IOS $1$",
675 " 5700 = Cisco-IOS $4$",
676 " 9200 = Cisco-IOS $8$",
677 " 9300 = Cisco-IOS $9$",
678 " 22 = Juniper Netscreen/SSG (ScreenOS)",
679 " 501 = Juniper IVE",
680 " 5800 = Android PIN",
681 " 8100 = Citrix Netscaler",
682 " 8500 = RACF",
683 " 7200 = GRUB 2",
684 " 9900 = Radmin2",
685 "",
686 "[[ Enterprise Application Software (EAS) ]]",
687 "",
688 " 7700 = SAP CODVN B (BCODE)",
689 " 7800 = SAP CODVN F/G (PASSCODE)",
690 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
691 " 8600 = Lotus Notes/Domino 5",
692 " 8700 = Lotus Notes/Domino 6",
693 " 9100 = Lotus Notes/Domino 8",
694 " 133 = PeopleSoft",
695 "",
696 "[[ Archives ]]",
697 "",
698 " 11600 = 7-Zip",
699 " 12500 = RAR3-hp",
700 " 13000 = RAR5",
701 " 13200 = AxCrypt",
702 " 13300 = AxCrypt in memory SHA1",
703 "",
704 "[[ Full-Disk encryptions (FDE) ]]",
705 "",
706 " 62XY = TrueCrypt 5.0+",
707 " X = 1 = PBKDF2-HMAC-RipeMD160",
708 " X = 2 = PBKDF2-HMAC-SHA512",
709 " X = 3 = PBKDF2-HMAC-Whirlpool",
710 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
711 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
712 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
713 " Y = 3 = XTS 1536 bit (Ciphers: All)",
714 " 8800 = Android FDE < v4.3",
715 " 12900 = Android FDE (Samsung DEK)",
716 " 12200 = eCryptfs",
717 "",
718 "[[ Documents ]]",
719 "",
720 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
721 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
722 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
723 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
724 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
725 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
726 " 9400 = MS Office 2007",
727 " 9500 = MS Office 2010",
728 " 9600 = MS Office 2013",
729 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
730 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
731 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
732 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
733 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
734 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
735 "",
736 "[[ Password Managers ]]",
737 "",
738 " 9000 = Password Safe v2",
739 " 5200 = Password Safe v3",
740 " 6800 = Lastpass",
741 " 6600 = 1Password, agilekeychain",
742 " 8200 = 1Password, cloudkeychain",
743 " 11300 = Bitcoin/Litecoin wallet.dat",
744 " 12700 = Blockchain, My Wallet",
745 "",
746 NULL
747 };
748
749 /**
750 * oclHashcat specific functions
751 */
752
753 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
754 {
755 int exec_pos = (int) device_param->exec_pos - last_num_entries;
756
757 if (exec_pos < 0) exec_pos += EXEC_CACHE;
758
759 double exec_ms_sum = 0;
760
761 int exec_ms_cnt = 0;
762
763 for (int i = 0; i < last_num_entries; i++)
764 {
765 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
766
767 if (exec_ms)
768 {
769 exec_ms_sum += exec_ms;
770
771 exec_ms_cnt++;
772 }
773 }
774
775 if (exec_ms_cnt == 0) return 0;
776
777 return exec_ms_sum / exec_ms_cnt;
778 }
779
780 void status_display_automat ()
781 {
782 FILE *out = stdout;
783
784 fprintf (out, "STATUS\t%u\t", data.devices_status);
785
786 /**
787 * speed new
788 */
789
790 fprintf (out, "SPEED\t");
791
792 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
793 {
794 hc_device_param_t *device_param = &data.devices_param[device_id];
795
796 if (device_param->skipped) continue;
797
798 u64 speed_cnt = 0;
799 float speed_ms = 0;
800
801 for (int i = 0; i < SPEED_CACHE; i++)
802 {
803 float rec_ms;
804
805 hc_timer_get (device_param->speed_rec[i], rec_ms);
806
807 if (rec_ms > SPEED_MAXAGE) continue;
808
809 speed_cnt += device_param->speed_cnt[i];
810 speed_ms += device_param->speed_ms[i];
811 }
812
813 speed_cnt /= SPEED_CACHE;
814 speed_ms /= SPEED_CACHE;
815
816 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
817 }
818
819 /**
820 * exec time
821 */
822
823 fprintf (out, "EXEC_RUNTIME\t");
824
825 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
826 {
827 hc_device_param_t *device_param = &data.devices_param[device_id];
828
829 if (device_param->skipped) continue;
830
831 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
832
833 fprintf (out, "%f\t", exec_ms_avg);
834 }
835
836 /**
837 * words_cur
838 */
839
840 u64 words_cur = get_lowest_words_done ();
841
842 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
843
844 /**
845 * counter
846 */
847
848 u64 progress_total = data.words_cnt * data.salts_cnt;
849
850 u64 all_done = 0;
851 u64 all_rejected = 0;
852 u64 all_restored = 0;
853
854 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
855 {
856 all_done += data.words_progress_done[salt_pos];
857 all_rejected += data.words_progress_rejected[salt_pos];
858 all_restored += data.words_progress_restored[salt_pos];
859 }
860
861 u64 progress_cur = all_restored + all_done + all_rejected;
862 u64 progress_end = progress_total;
863
864 u64 progress_skip = 0;
865
866 if (data.skip)
867 {
868 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
869
870 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
871 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
872 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
873 }
874
875 if (data.limit)
876 {
877 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
878
879 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
880 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
881 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
882 }
883
884 u64 progress_cur_relative_skip = progress_cur - progress_skip;
885 u64 progress_end_relative_skip = progress_end - progress_skip;
886
887 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
888
889 /**
890 * cracks
891 */
892
893 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
894 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
895
896 /**
897 * temperature
898 */
899
900 #ifdef HAVE_HWMON
901 if (data.gpu_temp_disable == 0)
902 {
903 fprintf (out, "TEMP\t");
904
905 hc_thread_mutex_lock (mux_adl);
906
907 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
908 {
909 hc_device_param_t *device_param = &data.devices_param[device_id];
910
911 if (device_param->skipped) continue;
912
913 int temp = hm_get_temperature_with_device_id (device_id);
914
915 fprintf (out, "%d\t", temp);
916 }
917
918 hc_thread_mutex_unlock (mux_adl);
919 }
920 #endif // HAVE_HWMON
921
922 /**
923 * flush
924 */
925
926 #ifdef _WIN
927 fputc ('\r', out);
928 fputc ('\n', out);
929 #endif
930
931 #ifdef _POSIX
932 fputc ('\n', out);
933 #endif
934
935 fflush (out);
936 }
937
938 void status_display ()
939 {
940 if (data.devices_status == STATUS_INIT) return;
941 if (data.devices_status == STATUS_STARTING) return;
942 if (data.devices_status == STATUS_BYPASS) return;
943
944 if (data.status_automat == 1)
945 {
946 status_display_automat ();
947
948 return;
949 }
950
951 char tmp_buf[1000] = { 0 };
952
953 uint tmp_len = 0;
954
955 log_info ("Session.Name...: %s", data.session);
956
957 char *status_type = strstatus (data.devices_status);
958
959 uint hash_mode = data.hash_mode;
960
961 char *hash_type = strhashtype (hash_mode); // not a bug
962
963 log_info ("Status.........: %s", status_type);
964
965 /**
966 * show rules
967 */
968
969 if (data.rp_files_cnt)
970 {
971 uint i;
972
973 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
974 {
975 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
976 }
977
978 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
979
980 log_info ("Rules.Type.....: %s", tmp_buf);
981
982 tmp_len = 0;
983 }
984
985 if (data.rp_gen)
986 {
987 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
988
989 if (data.rp_gen_seed)
990 {
991 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
992 }
993 }
994
995 /**
996 * show input
997 */
998
999 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1000 {
1001 if (data.wordlist_mode == WL_MODE_FILE)
1002 {
1003 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
1004 }
1005 else if (data.wordlist_mode == WL_MODE_STDIN)
1006 {
1007 log_info ("Input.Mode.....: Pipe");
1008 }
1009 }
1010 else if (data.attack_mode == ATTACK_MODE_COMBI)
1011 {
1012 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1013 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1014 }
1015 else if (data.attack_mode == ATTACK_MODE_BF)
1016 {
1017 char *mask = data.mask;
1018
1019 if (mask != NULL)
1020 {
1021 uint mask_len = data.css_cnt;
1022
1023 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1024
1025 if (mask_len > 0)
1026 {
1027 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1028 {
1029 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1030 {
1031 mask_len -= data.salts_buf[0].salt_len;
1032 }
1033 }
1034
1035 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1036
1037 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1038 }
1039
1040 if (data.maskcnt > 1)
1041 {
1042 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1043
1044 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1045 }
1046
1047 log_info ("Input.Mode.....: %s", tmp_buf);
1048 }
1049
1050 tmp_len = 0;
1051 }
1052 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1053 {
1054 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1055 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1056 }
1057 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1058 {
1059 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1060 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1061 }
1062
1063 if (data.digests_cnt == 1)
1064 {
1065 if (data.hash_mode == 2500)
1066 {
1067 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1068
1069 uint pke[25] = { 0 };
1070
1071 char *pke_ptr = (char *) pke;
1072
1073 for (uint i = 0; i < 25; i++)
1074 {
1075 pke[i] = byte_swap_32 (wpa->pke[i]);
1076 }
1077
1078 char mac1[6] = { 0 };
1079 char mac2[6] = { 0 };
1080
1081 memcpy (mac1, pke_ptr + 23, 6);
1082 memcpy (mac2, pke_ptr + 29, 6);
1083
1084 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1085 (char *) data.salts_buf[0].salt_buf,
1086 mac1[0] & 0xff,
1087 mac1[1] & 0xff,
1088 mac1[2] & 0xff,
1089 mac1[3] & 0xff,
1090 mac1[4] & 0xff,
1091 mac1[5] & 0xff,
1092 mac2[0] & 0xff,
1093 mac2[1] & 0xff,
1094 mac2[2] & 0xff,
1095 mac2[3] & 0xff,
1096 mac2[4] & 0xff,
1097 mac2[5] & 0xff);
1098 }
1099 else if (data.hash_mode == 5200)
1100 {
1101 log_info ("Hash.Target....: File (%s)", data.hashfile);
1102 }
1103 else if (data.hash_mode == 9000)
1104 {
1105 log_info ("Hash.Target....: File (%s)", data.hashfile);
1106 }
1107 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1108 {
1109 log_info ("Hash.Target....: File (%s)", data.hashfile);
1110 }
1111 else
1112 {
1113 char out_buf[4096] = { 0 };
1114
1115 ascii_digest (out_buf, 0, 0);
1116
1117 // limit length
1118 if (strlen (out_buf) > 40)
1119 {
1120 out_buf[41] = '.';
1121 out_buf[42] = '.';
1122 out_buf[43] = '.';
1123 out_buf[44] = 0;
1124 }
1125
1126 log_info ("Hash.Target....: %s", out_buf);
1127 }
1128 }
1129 else
1130 {
1131 if (data.hash_mode == 3000)
1132 {
1133 char out_buf1[4096] = { 0 };
1134 char out_buf2[4096] = { 0 };
1135
1136 ascii_digest (out_buf1, 0, 0);
1137 ascii_digest (out_buf2, 0, 1);
1138
1139 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1140 }
1141 else
1142 {
1143 log_info ("Hash.Target....: File (%s)", data.hashfile);
1144 }
1145 }
1146
1147 log_info ("Hash.Type......: %s", hash_type);
1148
1149 /**
1150 * speed new
1151 */
1152
1153 u64 speed_cnt[DEVICES_MAX] = { 0 };
1154 float speed_ms[DEVICES_MAX] = { 0 };
1155
1156 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1157 {
1158 hc_device_param_t *device_param = &data.devices_param[device_id];
1159
1160 if (device_param->skipped) continue;
1161
1162 // we need to clear values (set to 0) because in case the device does
1163 // not get new candidates it idles around but speed display would
1164 // show it as working.
1165 // if we instantly set it to 0 after reading it happens that the
1166 // speed can be shown as zero if the users refreshes too fast.
1167 // therefore, we add a timestamp when a stat was recorded and if its
1168 // too old we will not use it
1169
1170 speed_cnt[device_id] = 0;
1171 speed_ms[device_id] = 0;
1172
1173 for (int i = 0; i < SPEED_CACHE; i++)
1174 {
1175 float rec_ms;
1176
1177 hc_timer_get (device_param->speed_rec[i], rec_ms);
1178
1179 if (rec_ms > SPEED_MAXAGE) continue;
1180
1181 speed_cnt[device_id] += device_param->speed_cnt[i];
1182 speed_ms[device_id] += device_param->speed_ms[i];
1183 }
1184
1185 speed_cnt[device_id] /= SPEED_CACHE;
1186 speed_ms[device_id] /= SPEED_CACHE;
1187 }
1188
1189 float hashes_all_ms = 0;
1190
1191 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1192
1193 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1194 {
1195 hc_device_param_t *device_param = &data.devices_param[device_id];
1196
1197 if (device_param->skipped) continue;
1198
1199 hashes_dev_ms[device_id] = 0;
1200
1201 if (speed_ms[device_id])
1202 {
1203 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1204
1205 hashes_all_ms += hashes_dev_ms[device_id];
1206 }
1207 }
1208
1209 /**
1210 * exec time
1211 */
1212
1213 double exec_all_ms[DEVICES_MAX] = { 0 };
1214
1215 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1216 {
1217 hc_device_param_t *device_param = &data.devices_param[device_id];
1218
1219 if (device_param->skipped) continue;
1220
1221 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1222
1223 exec_all_ms[device_id] = exec_ms_avg;
1224 }
1225
1226 /**
1227 * timers
1228 */
1229
1230 float ms_running = 0;
1231
1232 hc_timer_get (data.timer_running, ms_running);
1233
1234 float ms_paused = data.ms_paused;
1235
1236 if (data.devices_status == STATUS_PAUSED)
1237 {
1238 float ms_paused_tmp = 0;
1239
1240 hc_timer_get (data.timer_paused, ms_paused_tmp);
1241
1242 ms_paused += ms_paused_tmp;
1243 }
1244
1245 #ifdef WIN
1246
1247 __time64_t sec_run = ms_running / 1000;
1248
1249 #else
1250
1251 time_t sec_run = ms_running / 1000;
1252
1253 #endif
1254
1255 if (sec_run)
1256 {
1257 char display_run[32] = { 0 };
1258
1259 struct tm tm_run;
1260
1261 struct tm *tmp = NULL;
1262
1263 #ifdef WIN
1264
1265 tmp = _gmtime64 (&sec_run);
1266
1267 #else
1268
1269 tmp = gmtime (&sec_run);
1270
1271 #endif
1272
1273 if (tmp != NULL)
1274 {
1275 memset (&tm_run, 0, sizeof (tm_run));
1276
1277 memcpy (&tm_run, tmp, sizeof (tm_run));
1278
1279 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1280
1281 char *start = ctime (&data.proc_start);
1282
1283 size_t start_len = strlen (start);
1284
1285 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1286 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1287
1288 log_info ("Time.Started...: %s (%s)", start, display_run);
1289 }
1290 }
1291 else
1292 {
1293 log_info ("Time.Started...: 0 secs");
1294 }
1295
1296 /**
1297 * counters
1298 */
1299
1300 u64 progress_total = data.words_cnt * data.salts_cnt;
1301
1302 u64 all_done = 0;
1303 u64 all_rejected = 0;
1304 u64 all_restored = 0;
1305
1306 u64 progress_noneed = 0;
1307
1308 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1309 {
1310 all_done += data.words_progress_done[salt_pos];
1311 all_rejected += data.words_progress_rejected[salt_pos];
1312 all_restored += data.words_progress_restored[salt_pos];
1313
1314 // Important for ETA only
1315
1316 if (data.salts_shown[salt_pos] == 1)
1317 {
1318 const u64 all = data.words_progress_done[salt_pos]
1319 + data.words_progress_rejected[salt_pos]
1320 + data.words_progress_restored[salt_pos];
1321
1322 const u64 left = data.words_cnt - all;
1323
1324 progress_noneed += left;
1325 }
1326 }
1327
1328 u64 progress_cur = all_restored + all_done + all_rejected;
1329 u64 progress_end = progress_total;
1330
1331 u64 progress_skip = 0;
1332
1333 if (data.skip)
1334 {
1335 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1336
1337 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1338 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1339 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1340 }
1341
1342 if (data.limit)
1343 {
1344 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1345
1346 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1347 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1348 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1349 }
1350
1351 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1352 u64 progress_end_relative_skip = progress_end - progress_skip;
1353
1354 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1355 {
1356 if (data.devices_status != STATUS_CRACKED)
1357 {
1358 #ifdef WIN
1359 __time64_t sec_etc = 0;
1360 #else
1361 time_t sec_etc = 0;
1362 #endif
1363
1364 if (hashes_all_ms)
1365 {
1366 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1367
1368 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1369
1370 sec_etc = ms_left / 1000;
1371 }
1372
1373 if (sec_etc == 0)
1374 {
1375 //log_info ("Time.Estimated.: 0 secs");
1376 }
1377 else if ((u64) sec_etc > ETC_MAX)
1378 {
1379 log_info ("Time.Estimated.: > 10 Years");
1380 }
1381 else
1382 {
1383 char display_etc[32] = { 0 };
1384
1385 struct tm tm_etc;
1386
1387 struct tm *tmp = NULL;
1388
1389 #ifdef WIN
1390
1391 tmp = _gmtime64 (&sec_etc);
1392
1393 #else
1394
1395 tmp = gmtime (&sec_etc);
1396
1397 #endif
1398
1399 if (tmp != NULL)
1400 {
1401 memset (&tm_etc, 0, sizeof (tm_etc));
1402
1403 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1404
1405 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1406
1407 time_t now;
1408
1409 time (&now);
1410
1411 now += sec_etc;
1412
1413 char *etc = ctime (&now);
1414
1415 size_t etc_len = strlen (etc);
1416
1417 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1418 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1419
1420 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1421 }
1422 }
1423 }
1424 }
1425
1426 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1427 {
1428 hc_device_param_t *device_param = &data.devices_param[device_id];
1429
1430 if (device_param->skipped) continue;
1431
1432 char display_dev_cur[16] = { 0 };
1433
1434 strncpy (display_dev_cur, "0.00", 4);
1435
1436 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1437
1438 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1439 }
1440
1441 char display_all_cur[16] = { 0 };
1442
1443 strncpy (display_all_cur, "0.00", 4);
1444
1445 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1446
1447 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1448
1449 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1450 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1451
1452 log_info ("Recovered......: %u/%u (%.2f%%) Digests, %u/%u (%.2f%%) Salts", data.digests_done, data.digests_cnt, digests_percent * 100, data.salts_done, data.salts_cnt, salts_percent * 100);
1453
1454 // crack-per-time
1455
1456 if (data.digests_cnt > 100)
1457 {
1458 time_t now = time (NULL);
1459
1460 int cpt_cur_min = 0;
1461 int cpt_cur_hour = 0;
1462 int cpt_cur_day = 0;
1463
1464 for (int i = 0; i < CPT_BUF; i++)
1465 {
1466 const uint cracked = data.cpt_buf[i].cracked;
1467 const time_t timestamp = data.cpt_buf[i].timestamp;
1468
1469 if ((timestamp + 60) > now)
1470 {
1471 cpt_cur_min += cracked;
1472 }
1473
1474 if ((timestamp + 3600) > now)
1475 {
1476 cpt_cur_hour += cracked;
1477 }
1478
1479 if ((timestamp + 86400) > now)
1480 {
1481 cpt_cur_day += cracked;
1482 }
1483 }
1484
1485 float ms_real = ms_running - ms_paused;
1486
1487 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1488 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1489 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1490
1491 if ((data.cpt_start + 86400) < now)
1492 {
1493 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1494 cpt_cur_min,
1495 cpt_cur_hour,
1496 cpt_cur_day,
1497 cpt_avg_min,
1498 cpt_avg_hour,
1499 cpt_avg_day);
1500 }
1501 else if ((data.cpt_start + 3600) < now)
1502 {
1503 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1504 cpt_cur_min,
1505 cpt_cur_hour,
1506 cpt_avg_min,
1507 cpt_avg_hour,
1508 cpt_avg_day);
1509 }
1510 else if ((data.cpt_start + 60) < now)
1511 {
1512 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1513 cpt_cur_min,
1514 cpt_avg_min,
1515 cpt_avg_hour,
1516 cpt_avg_day);
1517 }
1518 else
1519 {
1520 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1521 cpt_avg_min,
1522 cpt_avg_hour,
1523 cpt_avg_day);
1524 }
1525 }
1526
1527 // Restore point
1528
1529 u64 restore_point = get_lowest_words_done ();
1530
1531 u64 restore_total = data.words_base;
1532
1533 float percent_restore = 0;
1534
1535 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1536
1537 if (progress_end_relative_skip)
1538 {
1539 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1540 {
1541 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1542 float percent_rejected = 0.0;
1543
1544 if (progress_cur)
1545 {
1546 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1547 }
1548
1549 log_info ("Progress.......: %llu/%llu (%.02f%%)", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip, percent_finished * 100);
1550 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1551
1552 if (data.restore_disable == 0)
1553 {
1554 if (percent_finished != 1)
1555 {
1556 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1557 }
1558 }
1559 }
1560 }
1561 else
1562 {
1563 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1564 {
1565 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1566 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1567
1568 if (data.restore_disable == 0)
1569 {
1570 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1571 }
1572 }
1573 else
1574 {
1575 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1576 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1577
1578 // --restore not allowed if stdin is used -- really? why?
1579
1580 //if (data.restore_disable == 0)
1581 //{
1582 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1583 //}
1584 }
1585 }
1586
1587 #ifdef HAVE_HWMON
1588 if (data.gpu_temp_disable == 0)
1589 {
1590 hc_thread_mutex_lock (mux_adl);
1591
1592 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1593 {
1594 hc_device_param_t *device_param = &data.devices_param[device_id];
1595
1596 if (device_param->skipped) continue;
1597
1598 #define HM_STR_BUF_SIZE 255
1599
1600 if (data.hm_device[device_id].fan_supported == 1)
1601 {
1602 char utilization[HM_STR_BUF_SIZE] = { 0 };
1603 char temperature[HM_STR_BUF_SIZE] = { 0 };
1604 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1605
1606 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1607 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1608
1609 if (device_param->vendor_id == VENDOR_ID_AMD)
1610 {
1611 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1612 }
1613 else if (device_param->vendor_id == VENDOR_ID_NV)
1614 {
1615 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1616 }
1617
1618 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1619 }
1620 else
1621 {
1622 char utilization[HM_STR_BUF_SIZE] = { 0 };
1623 char temperature[HM_STR_BUF_SIZE] = { 0 };
1624
1625 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1626 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1627
1628 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1629 }
1630 }
1631
1632 hc_thread_mutex_unlock (mux_adl);
1633 }
1634 #endif // HAVE_HWMON
1635 }
1636
1637 static void status_benchmark ()
1638 {
1639 if (data.devices_status == STATUS_INIT) return;
1640 if (data.devices_status == STATUS_STARTING) return;
1641
1642 if (data.words_cnt == 0) return;
1643
1644 u64 speed_cnt[DEVICES_MAX] = { 0 };
1645 float speed_ms[DEVICES_MAX] = { 0 };
1646
1647 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1648 {
1649 hc_device_param_t *device_param = &data.devices_param[device_id];
1650
1651 if (device_param->skipped) continue;
1652
1653 speed_cnt[device_id] = 0;
1654 speed_ms[device_id] = 0;
1655
1656 for (int i = 0; i < SPEED_CACHE; i++)
1657 {
1658 speed_cnt[device_id] += device_param->speed_cnt[i];
1659 speed_ms[device_id] += device_param->speed_ms[i];
1660 }
1661
1662 speed_cnt[device_id] /= SPEED_CACHE;
1663 speed_ms[device_id] /= SPEED_CACHE;
1664 }
1665
1666 float hashes_all_ms = 0;
1667
1668 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1669
1670 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1671 {
1672 hc_device_param_t *device_param = &data.devices_param[device_id];
1673
1674 if (device_param->skipped) continue;
1675
1676 hashes_dev_ms[device_id] = 0;
1677
1678 if (speed_ms[device_id])
1679 {
1680 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1681
1682 hashes_all_ms += hashes_dev_ms[device_id];
1683 }
1684 }
1685
1686 /**
1687 * exec time
1688 */
1689
1690 double exec_all_ms[DEVICES_MAX] = { 0 };
1691
1692 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1693 {
1694 hc_device_param_t *device_param = &data.devices_param[device_id];
1695
1696 if (device_param->skipped) continue;
1697
1698 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1699
1700 exec_all_ms[device_id] = exec_ms_avg;
1701 }
1702
1703 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1704 {
1705 hc_device_param_t *device_param = &data.devices_param[device_id];
1706
1707 if (device_param->skipped) continue;
1708
1709 char display_dev_cur[16] = { 0 };
1710
1711 strncpy (display_dev_cur, "0.00", 4);
1712
1713 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1714
1715 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1716 }
1717
1718 char display_all_cur[16] = { 0 };
1719
1720 strncpy (display_all_cur, "0.00", 4);
1721
1722 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1723
1724 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1725 }
1726
1727 /**
1728 * oclHashcat -only- functions
1729 */
1730
1731 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1732 {
1733 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1734 {
1735 if (attack_kern == ATTACK_KERN_STRAIGHT)
1736 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1737 else if (attack_kern == ATTACK_KERN_COMBI)
1738 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1739 else if (attack_kern == ATTACK_KERN_BF)
1740 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1741 }
1742 else
1743 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1744 }
1745
1746 static void generate_cached_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1747 {
1748 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1749 {
1750 if (attack_kern == ATTACK_KERN_STRAIGHT)
1751 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1752 else if (attack_kern == ATTACK_KERN_COMBI)
1753 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1754 else if (attack_kern == ATTACK_KERN_BF)
1755 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1756 }
1757 else
1758 {
1759 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1760 }
1761 }
1762
1763 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1764 {
1765 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1766 {
1767 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1768 }
1769 else
1770 {
1771 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1772 }
1773 }
1774
1775 static void generate_cached_kernel_mp_filename (const uint opti_type, const uint opts_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1776 {
1777 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1778 {
1779 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1780 }
1781 else
1782 {
1783 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1784 }
1785 }
1786
1787 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1788 {
1789 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1790 }
1791
1792 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1793 {
1794 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1795 }
1796
1797 static uint convert_from_hex (char *line_buf, const uint line_len)
1798 {
1799 if (line_len & 1) return (line_len); // not in hex
1800
1801 if (data.hex_wordlist == 1)
1802 {
1803 uint i;
1804 uint j;
1805
1806 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1807 {
1808 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1809 }
1810
1811 memset (line_buf + i, 0, line_len - i);
1812
1813 return (i);
1814 }
1815 else if (line_len >= 6) // $HEX[] = 6
1816 {
1817 if (line_buf[0] != '$') return (line_len);
1818 if (line_buf[1] != 'H') return (line_len);
1819 if (line_buf[2] != 'E') return (line_len);
1820 if (line_buf[3] != 'X') return (line_len);
1821 if (line_buf[4] != '[') return (line_len);
1822 if (line_buf[line_len - 1] != ']') return (line_len);
1823
1824 uint i;
1825 uint j;
1826
1827 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1828 {
1829 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1830 }
1831
1832 memset (line_buf + i, 0, line_len - i);
1833
1834 return (i);
1835 }
1836
1837 return (line_len);
1838 }
1839
1840 static void clear_prompt ()
1841 {
1842 fputc ('\r', stdout);
1843
1844 for (size_t i = 0; i < strlen (PROMPT); i++)
1845 {
1846 fputc (' ', stdout);
1847 }
1848
1849 fputc ('\r', stdout);
1850
1851 fflush (stdout);
1852 }
1853
1854 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1855 {
1856 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, gidd * sizeof (pw_t), sizeof (pw_t), pw, 0, NULL, NULL);
1857 }
1858
1859 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1860 {
1861 char *outfile = data.outfile;
1862 uint quiet = data.quiet;
1863 FILE *pot_fp = data.pot_fp;
1864 uint loopback = data.loopback;
1865 uint debug_mode = data.debug_mode;
1866 char *debug_file = data.debug_file;
1867
1868 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1869 int debug_rule_len = 0; // -1 error
1870 uint debug_plain_len = 0;
1871
1872 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1873
1874 // hash
1875
1876 char out_buf[4096] = { 0 };
1877
1878 ascii_digest (out_buf, salt_pos, digest_pos);
1879
1880 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1881
1882 // plain
1883
1884 plain_t plain;
1885
1886 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, idx * sizeof (plain_t), sizeof (plain_t), &plain, 0, NULL, NULL);
1887
1888 uint gidvid = plain.gidvid;
1889 uint il_pos = plain.il_pos;
1890
1891 u64 crackpos = device_param->words_off;
1892
1893 uint plain_buf[16] = { 0 };
1894
1895 u8 *plain_ptr = (u8 *) plain_buf;
1896 unsigned int plain_len = 0;
1897
1898 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1899 {
1900 u64 gidd = gidvid;
1901 u64 gidm = 0;
1902
1903 pw_t pw;
1904
1905 gidd_to_pw_t (device_param, gidd, &pw);
1906
1907 for (int i = 0, j = gidm; i < 16; i++, j++)
1908 {
1909 plain_buf[i] = pw.i[j];
1910 }
1911
1912 plain_len = pw.pw_len;
1913
1914 const uint off = device_param->innerloop_pos + il_pos;
1915
1916 if (debug_mode > 0)
1917 {
1918 debug_rule_len = 0;
1919
1920 // save rule
1921 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1922 {
1923 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1924
1925 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1926 }
1927
1928 // save plain
1929 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1930 {
1931 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1932
1933 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1934
1935 debug_plain_len = plain_len;
1936 }
1937 }
1938
1939 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1940
1941 crackpos += gidvid;
1942 crackpos *= data.kernel_rules_cnt;
1943 crackpos += device_param->innerloop_pos + il_pos;
1944
1945 if (plain_len > data.pw_max) plain_len = data.pw_max;
1946 }
1947 else if (data.attack_mode == ATTACK_MODE_COMBI)
1948 {
1949 u64 gidd = gidvid;
1950 u64 gidm = 0;
1951
1952 pw_t pw;
1953
1954 gidd_to_pw_t (device_param, gidd, &pw);
1955
1956 for (int i = 0, j = gidm; i < 16; i++, j++)
1957 {
1958 plain_buf[i] = pw.i[j];
1959 }
1960
1961 plain_len = pw.pw_len;
1962
1963 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1964 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1965
1966 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1967 {
1968 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1969 }
1970 else
1971 {
1972 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1973
1974 memcpy (plain_ptr, comb_buf, comb_len);
1975 }
1976
1977 plain_len += comb_len;
1978
1979 crackpos += gidvid;
1980 crackpos *= data.combs_cnt;
1981 crackpos += device_param->innerloop_pos + il_pos;
1982
1983 if (data.pw_max != PW_DICTMAX1)
1984 {
1985 if (plain_len > data.pw_max) plain_len = data.pw_max;
1986 }
1987 }
1988 else if (data.attack_mode == ATTACK_MODE_BF)
1989 {
1990 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1991 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1992
1993 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1994 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1995
1996 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1997 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1998
1999 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2000 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2001
2002 plain_len = data.css_cnt;
2003
2004 crackpos += gidvid;
2005 crackpos *= data.bfs_cnt;
2006 crackpos += device_param->innerloop_pos + il_pos;
2007 }
2008 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2009 {
2010 u64 gidd = gidvid;
2011 u64 gidm = 0;
2012
2013 pw_t pw;
2014
2015 gidd_to_pw_t (device_param, gidd, &pw);
2016
2017 for (int i = 0, j = gidm; i < 16; i++, j++)
2018 {
2019 plain_buf[i] = pw.i[j];
2020 }
2021
2022 plain_len = pw.pw_len;
2023
2024 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2025
2026 uint start = 0;
2027 uint stop = device_param->kernel_params_mp_buf32[4];
2028
2029 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2030
2031 plain_len += start + stop;
2032
2033 crackpos += gidvid;
2034 crackpos *= data.combs_cnt;
2035 crackpos += device_param->innerloop_pos + il_pos;
2036
2037 if (data.pw_max != PW_DICTMAX1)
2038 {
2039 if (plain_len > data.pw_max) plain_len = data.pw_max;
2040 }
2041 }
2042 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2043 {
2044 u64 gidd = gidvid;
2045 u64 gidm = 0;
2046
2047 pw_t pw;
2048
2049 gidd_to_pw_t (device_param, gidd, &pw);
2050
2051 for (int i = 0, j = gidm; i < 16; i++, j++)
2052 {
2053 plain_buf[i] = pw.i[j];
2054 }
2055
2056 plain_len = pw.pw_len;
2057
2058 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2059
2060 uint start = 0;
2061 uint stop = device_param->kernel_params_mp_buf32[4];
2062
2063 memmove (plain_ptr + stop, plain_ptr, plain_len);
2064
2065 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2066
2067 plain_len += start + stop;
2068
2069 crackpos += gidvid;
2070 crackpos *= data.combs_cnt;
2071 crackpos += device_param->innerloop_pos + il_pos;
2072
2073 if (data.pw_max != PW_DICTMAX1)
2074 {
2075 if (plain_len > data.pw_max) plain_len = data.pw_max;
2076 }
2077 }
2078
2079 if (data.attack_mode == ATTACK_MODE_BF)
2080 {
2081 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2082 {
2083 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2084 {
2085 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2086 {
2087 plain_len = plain_len - data.salts_buf[0].salt_len;
2088 }
2089 }
2090
2091 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2092 {
2093 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2094 {
2095 plain_ptr[j] = plain_ptr[i];
2096 }
2097
2098 plain_len = plain_len / 2;
2099 }
2100 }
2101 }
2102
2103 // if enabled, update also the potfile
2104
2105 if (pot_fp)
2106 {
2107 lock_file (pot_fp);
2108
2109 fprintf (pot_fp, "%s:", out_buf);
2110
2111 format_plain (pot_fp, plain_ptr, plain_len, 1);
2112
2113 fputc ('\n', pot_fp);
2114
2115 fflush (pot_fp);
2116
2117 unlock_file (pot_fp);
2118 }
2119
2120 // outfile
2121
2122 FILE *out_fp = NULL;
2123
2124 if (outfile != NULL)
2125 {
2126 if ((out_fp = fopen (outfile, "ab")) == NULL)
2127 {
2128 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2129
2130 out_fp = stdout;
2131 }
2132 lock_file (out_fp);
2133 }
2134 else
2135 {
2136 out_fp = stdout;
2137
2138 if (quiet == 0) clear_prompt ();
2139 }
2140
2141 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2142
2143 if (outfile != NULL)
2144 {
2145 if (out_fp != stdout)
2146 {
2147 fclose (out_fp);
2148 }
2149 }
2150 else
2151 {
2152 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2153 {
2154 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2155 {
2156 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2157 if (quiet == 0) fflush (stdout);
2158 }
2159 }
2160 }
2161
2162 // loopback
2163
2164 if (loopback)
2165 {
2166 char *loopback_file = data.loopback_file;
2167
2168 FILE *fb_fp = NULL;
2169
2170 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2171 {
2172 lock_file (fb_fp);
2173
2174 format_plain (fb_fp, plain_ptr, plain_len, 1);
2175
2176 fputc ('\n', fb_fp);
2177
2178 fclose (fb_fp);
2179 }
2180 }
2181
2182 // (rule) debug mode
2183
2184 // the next check implies that:
2185 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2186 // - debug_mode > 0
2187
2188 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2189 {
2190 if (debug_rule_len < 0) debug_rule_len = 0;
2191
2192 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2193
2194 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2195
2196 if ((quiet == 0) && (debug_file == NULL))
2197 {
2198 fprintf (stdout, "%s", PROMPT);
2199 fflush (stdout);
2200 }
2201 }
2202 }
2203
2204 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2205 {
2206 salt_t *salt_buf = &data.salts_buf[salt_pos];
2207
2208 int found = 0;
2209
2210 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2211
2212 for (uint i = 0; i < KERNEL_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2213
2214 if (found == 1)
2215 {
2216 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2217
2218 log_info_nn ("");
2219
2220 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL);
2221
2222 uint cpt_cracked = 0;
2223
2224 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2225 {
2226 uint idx = salt_buf->digests_offset + digest_pos;
2227
2228 if (data.digests_shown_tmp[idx] == 0) continue;
2229
2230 if (data.digests_shown[idx] == 1) continue;
2231
2232 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2233 {
2234 data.digests_shown[idx] = 1;
2235
2236 data.digests_done++;
2237
2238 cpt_cracked++;
2239
2240 salt_buf->digests_done++;
2241
2242 if (salt_buf->digests_done == salt_buf->digests_cnt)
2243 {
2244 data.salts_shown[salt_pos] = 1;
2245
2246 data.salts_done++;
2247 }
2248 }
2249
2250 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2251
2252 check_hash (device_param, salt_pos, digest_pos);
2253 }
2254
2255 if (cpt_cracked > 0)
2256 {
2257 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2258 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2259
2260 data.cpt_pos++;
2261
2262 data.cpt_total += cpt_cracked;
2263
2264 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2265 }
2266
2267 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2268 {
2269 // we need to reset cracked state on the device
2270 // otherwise host thinks again and again the hash was cracked
2271 // and returns invalid password each time
2272
2273 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2274
2275 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL);
2276 }
2277
2278 memset (device_param->result, 0, device_param->size_results);
2279
2280 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2281 }
2282 }
2283
2284 static void save_hash ()
2285 {
2286 char *hashfile = data.hashfile;
2287
2288 char new_hashfile[256] = { 0 };
2289 char old_hashfile[256] = { 0 };
2290
2291 snprintf (new_hashfile, 255, "%s.new", hashfile);
2292 snprintf (old_hashfile, 255, "%s.old", hashfile);
2293
2294 unlink (new_hashfile);
2295
2296 char separator = data.separator;
2297
2298 FILE *fp = fopen (new_hashfile, "wb");
2299
2300 if (fp == NULL)
2301 {
2302 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2303
2304 exit (-1);
2305 }
2306
2307 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2308 {
2309 if (data.salts_shown[salt_pos] == 1) continue;
2310
2311 salt_t *salt_buf = &data.salts_buf[salt_pos];
2312
2313 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2314 {
2315 uint idx = salt_buf->digests_offset + digest_pos;
2316
2317 if (data.digests_shown[idx] == 1) continue;
2318
2319 if (data.hash_mode != 2500)
2320 {
2321 char out_buf[4096] = { 0 };
2322
2323 if (data.username == 1)
2324 {
2325 user_t *user = data.hash_info[idx]->user;
2326
2327 uint i;
2328
2329 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2330
2331 fputc (separator, fp);
2332 }
2333
2334 ascii_digest (out_buf, salt_pos, digest_pos);
2335
2336 fputs (out_buf, fp);
2337
2338 log_out (fp, "");
2339 }
2340 else
2341 {
2342 hccap_t hccap;
2343
2344 to_hccap_t (&hccap, salt_pos, digest_pos);
2345
2346 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2347 }
2348 }
2349 }
2350
2351 fflush (fp);
2352
2353 fclose (fp);
2354
2355 unlink (old_hashfile);
2356
2357 if (rename (hashfile, old_hashfile) != 0)
2358 {
2359 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2360
2361 exit (-1);
2362 }
2363
2364 unlink (hashfile);
2365
2366 if (rename (new_hashfile, hashfile) != 0)
2367 {
2368 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2369
2370 exit (-1);
2371 }
2372
2373 unlink (old_hashfile);
2374 }
2375
2376 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2377 {
2378 // function called only in case kernel_power_all > words_left
2379
2380 float kernel_power_div = (float) (total_left) / kernel_power_all;
2381
2382 kernel_power_div += kernel_power_div / 100;
2383
2384 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2385
2386 while (kernel_power_new < total_left)
2387 {
2388 kernel_power_div += kernel_power_div / 100;
2389
2390 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2391 }
2392
2393 if (data.quiet == 0)
2394 {
2395 clear_prompt ();
2396
2397 log_info ("");
2398
2399 log_info ("INFO: approaching final keyspace, workload adjusted");
2400
2401 log_info ("");
2402
2403 fprintf (stdout, "%s", PROMPT);
2404
2405 fflush (stdout);
2406 }
2407
2408 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2409
2410 return kernel_power_div;
2411 }
2412
2413 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2414 {
2415 uint num_elements = num;
2416
2417 device_param->kernel_params_buf32[30] = data.combs_mode;
2418 device_param->kernel_params_buf32[31] = num;
2419
2420 uint kernel_threads = device_param->kernel_threads;
2421
2422 while (num_elements % kernel_threads) num_elements++;
2423
2424 cl_kernel kernel = NULL;
2425
2426 switch (kern_run)
2427 {
2428 case KERN_RUN_1: kernel = device_param->kernel1; break;
2429 case KERN_RUN_12: kernel = device_param->kernel12; break;
2430 case KERN_RUN_2: kernel = device_param->kernel2; break;
2431 case KERN_RUN_23: kernel = device_param->kernel23; break;
2432 case KERN_RUN_3: kernel = device_param->kernel3; break;
2433 }
2434
2435 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2436 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2437 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2438 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2439 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2440 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2441 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2442 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2443 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2444 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2445 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2446
2447 hc_timer_t timer;
2448
2449 hc_timer_set (&timer);
2450
2451 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2452 {
2453 const size_t global_work_size[3] = { num_elements, 32, 1 };
2454 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2455
2456 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2457 }
2458 else
2459 {
2460 size_t workgroup_size = 0;
2461
2462 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2463
2464 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2465
2466 const size_t global_work_size[3] = { num_elements, 1, 1 };
2467 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2468
2469 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2470 }
2471
2472 hc_clFlush (data.ocl, device_param->command_queue);
2473
2474 hc_clFinish (data.ocl, device_param->command_queue);
2475
2476 if (event_update)
2477 {
2478 float exec_time;
2479
2480 hc_timer_get (timer, exec_time);
2481
2482 uint exec_pos = device_param->exec_pos;
2483
2484 device_param->exec_ms[exec_pos] = exec_time;
2485
2486 exec_pos++;
2487
2488 if (exec_pos == EXEC_CACHE)
2489 {
2490 exec_pos = 0;
2491 }
2492
2493 device_param->exec_pos = exec_pos;
2494 }
2495 }
2496
2497 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2498 {
2499 uint num_elements = num;
2500
2501 switch (kern_run)
2502 {
2503 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2504 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2505 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2506 }
2507
2508 // causes problems with special threads like in bcrypt
2509 // const uint kernel_threads = device_param->kernel_threads;
2510
2511 uint kernel_threads = KERNEL_THREADS;
2512
2513 while (num_elements % kernel_threads) num_elements++;
2514
2515 cl_kernel kernel = NULL;
2516
2517 switch (kern_run)
2518 {
2519 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2520 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2521 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2522 }
2523
2524 switch (kern_run)
2525 {
2526 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2527 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2528 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2529 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2530 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2531 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2532 break;
2533 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2534 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2535 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2536 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2537 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2538 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2539 break;
2540 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2541 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2542 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2543 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2544 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2545 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2546 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2547 break;
2548 }
2549
2550 size_t workgroup_size = 0;
2551 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), &workgroup_size, NULL);
2552 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2553
2554 const size_t global_work_size[3] = { num_elements, 1, 1 };
2555 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2556
2557 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2558
2559 hc_clFlush (data.ocl, device_param->command_queue);
2560
2561 hc_clFinish (data.ocl, device_param->command_queue);
2562 }
2563
2564 static void run_kernel_tm (hc_device_param_t *device_param)
2565 {
2566 const uint num_elements = 1024; // fixed
2567
2568 uint kernel_threads = 32;
2569
2570 cl_kernel kernel = device_param->kernel_tm;
2571
2572 size_t workgroup_size = 0;
2573 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2574 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2575
2576 const size_t global_work_size[3] = { num_elements, 1, 1 };
2577 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2578
2579 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2580
2581 hc_clFlush (data.ocl, device_param->command_queue);
2582
2583 hc_clFinish (data.ocl, device_param->command_queue);
2584 }
2585
2586 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2587 {
2588 uint num_elements = num;
2589
2590 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2591 device_param->kernel_params_amp_buf32[6] = num_elements;
2592
2593 // causes problems with special threads like in bcrypt
2594 // const uint kernel_threads = device_param->kernel_threads;
2595
2596 uint kernel_threads = KERNEL_THREADS;
2597
2598 while (num_elements % kernel_threads) num_elements++;
2599
2600 cl_kernel kernel = device_param->kernel_amp;
2601
2602 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2603 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2604
2605 size_t workgroup_size = 0;
2606 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2607 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2608
2609 const size_t global_work_size[3] = { num_elements, 1, 1 };
2610 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2611
2612 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2613
2614 hc_clFlush (data.ocl, device_param->command_queue);
2615
2616 hc_clFinish (data.ocl, device_param->command_queue);
2617 }
2618
2619 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2620 {
2621 int rc = -1;
2622
2623 if (device_param->opencl_v12 && device_param->vendor_id == VENDOR_ID_AMD)
2624 {
2625 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2626
2627 const cl_uchar zero = 0;
2628
2629 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2630 }
2631
2632 if (rc != 0)
2633 {
2634 // NOTE: clEnqueueFillBuffer () always fails with -59
2635 // IOW, it's not supported by Nvidia ForceWare <= 352.21, also pocl segfaults, also on apple
2636 // How's that possible, OpenCL 1.2 support is advertised??
2637 // We need to workaround...
2638
2639 #define FILLSZ 0x100000
2640
2641 char *tmp = (char *) mymalloc (FILLSZ);
2642
2643 for (uint i = 0; i < size; i += FILLSZ)
2644 {
2645 const int left = size - i;
2646
2647 const int fillsz = MIN (FILLSZ, left);
2648
2649 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2650 }
2651
2652 myfree (tmp);
2653 }
2654 }
2655
2656 static void choose_kernel (hc_device_param_t *device_param, const uint attack_exec, const uint attack_mode, const uint opts_type, const salt_t *salt_buf, const uint highest_pw_len, const uint pws_cnt)
2657 {
2658 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2659 {
2660 if (attack_mode == ATTACK_MODE_BF)
2661 {
2662 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2663 {
2664 const uint size_tm = 32 * sizeof (bs_word_t);
2665
2666 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2667
2668 run_kernel_tm (device_param);
2669
2670 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_tm_c, device_param->d_bfs_c, 0, 0, size_tm, 0, NULL, NULL);
2671 }
2672 }
2673
2674 if (highest_pw_len < 16)
2675 {
2676 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2677 }
2678 else if (highest_pw_len < 32)
2679 {
2680 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2681 }
2682 else
2683 {
2684 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2685 }
2686 }
2687 else
2688 {
2689 run_kernel_amp (device_param, pws_cnt);
2690
2691 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2692
2693 if (opts_type & OPTS_TYPE_HOOK12)
2694 {
2695 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2696 }
2697
2698 uint iter = salt_buf->salt_iter;
2699
2700 uint loop_step = device_param->kernel_loops;
2701
2702 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2703 {
2704 uint loop_left = iter - loop_pos;
2705
2706 loop_left = MIN (loop_left, loop_step);
2707
2708 device_param->kernel_params_buf32[25] = loop_pos;
2709 device_param->kernel_params_buf32[26] = loop_left;
2710
2711 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2712
2713 if (data.devices_status == STATUS_CRACKED) break;
2714 if (data.devices_status == STATUS_ABORTED) break;
2715 if (data.devices_status == STATUS_QUIT) break;
2716 }
2717
2718 if (opts_type & OPTS_TYPE_HOOK23)
2719 {
2720 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2721
2722 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2723
2724 // do something with data
2725
2726 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2727 }
2728
2729 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2730 }
2731 }
2732
2733 static int run_rule_engine (const int rule_len, const char *rule_buf)
2734 {
2735 if (rule_len == 0)
2736 {
2737 return 0;
2738 }
2739 else if (rule_len == 1)
2740 {
2741 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2742 }
2743
2744 return 1;
2745 }
2746
2747 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2748 {
2749 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2750 {
2751 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2752 }
2753 else if (data.attack_kern == ATTACK_KERN_COMBI)
2754 {
2755 if (data.attack_mode == ATTACK_MODE_HYBRID2)
2756 {
2757 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2758 {
2759 for (u32 i = 0; i < pws_cnt; i++)
2760 {
2761 const u32 pw_len = device_param->pws_buf[i].pw_len;
2762
2763 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2764
2765 ptr[pw_len] = 0x01;
2766 }
2767 }
2768 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2769 {
2770 for (u32 i = 0; i < pws_cnt; i++)
2771 {
2772 const u32 pw_len = device_param->pws_buf[i].pw_len;
2773
2774 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2775
2776 ptr[pw_len] = 0x80;
2777 }
2778 }
2779 }
2780
2781 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2782 }
2783 else if (data.attack_kern == ATTACK_KERN_BF)
2784 {
2785 const u64 off = device_param->words_off;
2786
2787 device_param->kernel_params_mp_l_buf64[3] = off;
2788
2789 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2790 }
2791 }
2792
2793 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops, const int repeat)
2794 {
2795 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2796
2797 device_param->kernel_params_buf32[26] = kernel_loops;
2798 device_param->kernel_params_buf32[27] = kernel_loops;
2799
2800 // init some fake words
2801
2802 for (u32 i = 0; i < kernel_power; i++)
2803 {
2804 device_param->pws_buf[i].i[0] = i;
2805 device_param->pws_buf[i].i[1] = 0x01234567;
2806 device_param->pws_buf[i].pw_len = 4 + (i & 3);
2807 }
2808
2809 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, kernel_power * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2810
2811 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2812 {
2813 run_kernel_amp (device_param, kernel_power);
2814 }
2815
2816 // caching run
2817
2818 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2819 {
2820 run_kernel (KERN_RUN_1, device_param, kernel_power, false);
2821 }
2822 else
2823 {
2824 run_kernel (KERN_RUN_2, device_param, kernel_power, false);
2825 }
2826
2827 // now user repeats
2828
2829 for (int i = 0; i < repeat; i++)
2830 {
2831 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2832 {
2833 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2834 }
2835 else
2836 {
2837 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2838 }
2839 }
2840
2841 const double exec_ms_prev = get_avg_exec_time (device_param, repeat);
2842
2843 // reset fake words
2844
2845 memset (device_param->pws_buf, 0, kernel_power * sizeof (pw_t));
2846
2847 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, kernel_power * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2848 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_amp_buf, CL_TRUE, 0, kernel_power * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2849
2850 return exec_ms_prev;
2851 }
2852
2853 static void autotune (hc_device_param_t *device_param)
2854 {
2855 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2856
2857 const u32 kernel_accel_min = device_param->kernel_accel_min;
2858 const u32 kernel_accel_max = device_param->kernel_accel_max;
2859
2860 const u32 kernel_loops_min = device_param->kernel_loops_min;
2861 const u32 kernel_loops_max = device_param->kernel_loops_max;
2862
2863 u32 kernel_accel = kernel_accel_min;
2864 u32 kernel_loops = kernel_loops_min;
2865
2866 // steps
2867
2868 #define STEPS_CNT 10
2869
2870 #define STEPS_ACCEL_CNT (STEPS_CNT + 2)
2871 #define STEPS_LOOPS_CNT (STEPS_CNT + 2)
2872
2873 u32 steps_accel[STEPS_ACCEL_CNT];
2874 u32 steps_loops[STEPS_LOOPS_CNT];
2875
2876 for (int i = 0; i < STEPS_ACCEL_CNT; i++)
2877 {
2878 steps_accel[i] = 1 << i;
2879 }
2880
2881 for (int i = 0; i < STEPS_LOOPS_CNT; i++)
2882 {
2883 steps_loops[i] = 1 << i;
2884 }
2885
2886 steps_accel[STEPS_CNT + 0] = kernel_accel_min;
2887 steps_accel[STEPS_CNT + 1] = kernel_accel_max;
2888
2889 steps_loops[STEPS_CNT + 0] = kernel_loops_min;
2890 steps_loops[STEPS_CNT + 1] = kernel_loops_max;
2891
2892 qsort (steps_accel, STEPS_ACCEL_CNT, sizeof (u32), sort_by_u32);
2893 qsort (steps_loops, STEPS_LOOPS_CNT, sizeof (u32), sort_by_u32);
2894
2895 // find out highest kernel-loops that stays below target_ms, we can use it later for multiplication as this is a linear function
2896
2897 u32 kernel_loops_tmp;
2898
2899 for (kernel_loops_tmp = kernel_loops_max; kernel_loops_tmp > kernel_loops_min; kernel_loops_tmp >>= 1)
2900 {
2901 const double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops_tmp, 1);
2902
2903 if (exec_ms < target_ms) break;
2904 }
2905
2906 // kernel-accel
2907
2908 if (kernel_accel_min < kernel_accel_max)
2909 {
2910 double e_best = 0;
2911
2912 for (int i = 0; i < STEPS_ACCEL_CNT; i++)
2913 {
2914 const u32 kernel_accel_try = steps_accel[i];
2915
2916 if (kernel_accel_try < kernel_accel_min) continue;
2917 if (kernel_accel_try > kernel_accel_max) break;
2918
2919 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_tmp, 1);
2920
2921 if (exec_ms > target_ms) break;
2922
2923 const double e = kernel_accel_try / exec_ms;
2924
2925 if (e > e_best)
2926 {
2927 kernel_accel = kernel_accel_try;
2928
2929 e_best = e;
2930 }
2931 }
2932 }
2933
2934 // kernel-loops final
2935
2936 if (kernel_loops_min < kernel_loops_max)
2937 {
2938 double e_best = 0;
2939
2940 for (int i = 0; i < STEPS_LOOPS_CNT; i++)
2941 {
2942 const u32 kernel_loops_try = steps_loops[i];
2943
2944 if (kernel_loops_try < kernel_loops_min) continue;
2945 if (kernel_loops_try > kernel_loops_max) break;
2946
2947 const double exec_ms = try_run (device_param, kernel_accel, kernel_loops_try, 1);
2948
2949 if (exec_ms > target_ms) break;
2950
2951 const double e = kernel_loops_try / exec_ms;
2952
2953 if (e > e_best)
2954 {
2955 kernel_loops = kernel_loops_try;
2956
2957 e_best = e;
2958 }
2959 }
2960 }
2961
2962 // final balance
2963
2964 u32 kernel_accel_best = kernel_accel;
2965 u32 kernel_loops_best = kernel_loops;
2966
2967 u32 exec_best = -1;
2968
2969 if ((kernel_accel_min < kernel_accel_max) || (kernel_loops_min < kernel_loops_max))
2970 {
2971 const double exec_ms = try_run (device_param, kernel_accel_best, kernel_loops_best, 1);
2972
2973 exec_best = exec_ms;
2974 }
2975
2976 // reset
2977
2978 if (kernel_accel_min < kernel_accel_max)
2979 {
2980 u32 kernel_accel_try = kernel_accel;
2981 u32 kernel_loops_try = kernel_loops;
2982
2983 for (int i = 0; i < 2; i++)
2984 {
2985 kernel_accel_try >>= 1;
2986 kernel_loops_try <<= 1;
2987
2988 if (kernel_accel_try < kernel_accel_min) break;
2989 if (kernel_loops_try > kernel_loops_max) break;
2990
2991 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
2992
2993 if (exec_ms < exec_best)
2994 {
2995 kernel_accel_best = kernel_accel_try;
2996 kernel_loops_best = kernel_loops_try;
2997
2998 exec_best = exec_ms;
2999 }
3000 }
3001 }
3002
3003 // reset
3004
3005 if (kernel_loops_min < kernel_loops_max)
3006 {
3007 u32 kernel_accel_try = kernel_accel;
3008 u32 kernel_loops_try = kernel_loops;
3009
3010 for (int i = 0; i < 2; i++)
3011 {
3012 kernel_accel_try <<= 1;
3013 kernel_loops_try >>= 1;
3014
3015 if (kernel_accel_try > kernel_accel_max) break;
3016 if (kernel_loops_try < kernel_loops_min) break;
3017
3018 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
3019
3020 if (exec_ms < exec_best)
3021 {
3022 kernel_accel_best = kernel_accel_try;
3023 kernel_loops_best = kernel_loops_try;
3024
3025 exec_best = exec_ms;
3026 }
3027 }
3028 }
3029
3030 // reset timer
3031
3032 device_param->exec_pos = 0;
3033
3034 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3035
3036 // store
3037
3038 kernel_accel = kernel_accel_best;
3039 kernel_loops = kernel_loops_best;
3040
3041 device_param->kernel_accel = kernel_accel;
3042 device_param->kernel_loops = kernel_loops;
3043
3044 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3045
3046 device_param->kernel_power = kernel_power;
3047
3048 #ifdef DEBUG
3049
3050 if (data.quiet == 0)
3051 {
3052 clear_prompt ();
3053
3054 log_info ("Device #%u: autotuned kernel-accel to %u\n"
3055 "Device #%u: autotuned kernel-loops to %u\n",
3056 device_param->device_id + 1,
3057 kernel_accel,
3058 device_param->device_id + 1,
3059 kernel_loops);
3060
3061 fprintf (stdout, "%s", PROMPT);
3062 fflush (stdout);
3063 }
3064
3065 #endif
3066 }
3067
3068 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3069 {
3070 // init speed timer
3071
3072 uint speed_pos = device_param->speed_pos;
3073
3074 #ifdef _POSIX
3075 if (device_param->timer_speed.tv_sec == 0)
3076 {
3077 hc_timer_set (&device_param->timer_speed);
3078 }
3079 #endif
3080
3081 #ifdef _WIN
3082 if (device_param->timer_speed.QuadPart == 0)
3083 {
3084 hc_timer_set (&device_param->timer_speed);
3085 }
3086 #endif
3087
3088 // find higest password length, this is for optimization stuff
3089
3090 uint highest_pw_len = 0;
3091
3092 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3093 {
3094 }
3095 else if (data.attack_kern == ATTACK_KERN_COMBI)
3096 {
3097 }
3098 else if (data.attack_kern == ATTACK_KERN_BF)
3099 {
3100 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3101 + device_param->kernel_params_mp_l_buf32[5];
3102 }
3103
3104 // iteration type
3105
3106 uint innerloop_step = 0;
3107 uint innerloop_cnt = 0;
3108
3109 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3110 else innerloop_step = 1;
3111
3112 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3113 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3114 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3115
3116 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3117
3118 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3119 {
3120 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3121
3122 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3123
3124 if (data.devices_status == STATUS_CRACKED) break;
3125 if (data.devices_status == STATUS_ABORTED) break;
3126 if (data.devices_status == STATUS_QUIT) break;
3127 if (data.devices_status == STATUS_BYPASS) break;
3128
3129 salt_t *salt_buf = &data.salts_buf[salt_pos];
3130
3131 device_param->kernel_params_buf32[24] = salt_pos;
3132 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3133 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3134
3135 FILE *combs_fp = device_param->combs_fp;
3136
3137 if (data.attack_mode == ATTACK_MODE_COMBI)
3138 {
3139 rewind (combs_fp);
3140 }
3141
3142 // innerloops
3143
3144 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3145 {
3146 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3147
3148 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3149
3150 if (data.devices_status == STATUS_CRACKED) break;
3151 if (data.devices_status == STATUS_ABORTED) break;
3152 if (data.devices_status == STATUS_QUIT) break;
3153 if (data.devices_status == STATUS_BYPASS) break;
3154
3155 uint innerloop_left = innerloop_cnt - innerloop_pos;
3156
3157 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3158
3159 device_param->innerloop_pos = innerloop_pos;
3160 device_param->innerloop_left = innerloop_left;
3161
3162 device_param->kernel_params_buf32[27] = innerloop_left;
3163
3164 // i think we can get rid of this
3165 if (innerloop_left == 0)
3166 {
3167 puts ("bug, how should this happen????\n");
3168
3169 continue;
3170 }
3171
3172 if (data.salts_shown[salt_pos] == 1)
3173 {
3174 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3175
3176 continue;
3177 }
3178
3179 // initialize amplifiers
3180
3181 if (data.attack_mode == ATTACK_MODE_COMBI)
3182 {
3183 char line_buf[BUFSIZ] = { 0 };
3184
3185 uint i = 0;
3186
3187 while (i < innerloop_left)
3188 {
3189 if (feof (combs_fp)) break;
3190
3191 int line_len = fgetl (combs_fp, line_buf);
3192
3193 if (line_len >= PW_MAX1) continue;
3194
3195 line_len = convert_from_hex (line_buf, line_len);
3196
3197 char *line_buf_new = line_buf;
3198
3199 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3200 {
3201 char rule_buf_out[BLOCK_SIZE] = { 0 };
3202
3203 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3204
3205 if (rule_len_out < 0)
3206 {
3207 data.words_progress_rejected[salt_pos] += pws_cnt;
3208
3209 continue;
3210 }
3211
3212 line_len = rule_len_out;
3213
3214 line_buf_new = rule_buf_out;
3215 }
3216
3217 line_len = MIN (line_len, PW_DICTMAX);
3218
3219 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3220
3221 memcpy (ptr, line_buf_new, line_len);
3222
3223 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3224
3225 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3226 {
3227 uppercase (ptr, line_len);
3228 }
3229
3230 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3231 {
3232 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3233 {
3234 ptr[line_len] = 0x80;
3235 }
3236
3237 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3238 {
3239 ptr[line_len] = 0x01;
3240 }
3241 }
3242
3243 device_param->combs_buf[i].pw_len = line_len;
3244
3245 i++;
3246 }
3247
3248 for (uint j = i; j < innerloop_left; j++)
3249 {
3250 device_param->combs_buf[j].i[0] = 0;
3251 device_param->combs_buf[j].i[1] = 0;
3252 device_param->combs_buf[j].i[2] = 0;
3253 device_param->combs_buf[j].i[3] = 0;
3254 device_param->combs_buf[j].i[4] = 0;
3255 device_param->combs_buf[j].i[5] = 0;
3256 device_param->combs_buf[j].i[6] = 0;
3257 device_param->combs_buf[j].i[7] = 0;
3258
3259 device_param->combs_buf[j].pw_len = 0;
3260 }
3261
3262 innerloop_left = i;
3263 }
3264 else if (data.attack_mode == ATTACK_MODE_BF)
3265 {
3266 u64 off = innerloop_pos;
3267
3268 device_param->kernel_params_mp_r_buf64[3] = off;
3269
3270 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3271 }
3272 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3273 {
3274 u64 off = innerloop_pos;
3275
3276 device_param->kernel_params_mp_buf64[3] = off;
3277
3278 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3279 }
3280 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3281 {
3282 u64 off = innerloop_pos;
3283
3284 device_param->kernel_params_mp_buf64[3] = off;
3285
3286 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3287 }
3288
3289 // copy amplifiers
3290
3291 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3292 {
3293 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_rules, device_param->d_rules_c, innerloop_pos * sizeof (kernel_rule_t), 0, innerloop_left * sizeof (kernel_rule_t), 0, NULL, NULL);
3294 }
3295 else if (data.attack_mode == ATTACK_MODE_COMBI)
3296 {
3297 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_combs_c, CL_TRUE, 0, innerloop_left * sizeof (comb_t), device_param->combs_buf, 0, NULL, NULL);
3298 }
3299 else if (data.attack_mode == ATTACK_MODE_BF)
3300 {
3301 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_bfs, device_param->d_bfs_c, 0, 0, innerloop_left * sizeof (bf_t), 0, NULL, NULL);
3302 }
3303 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3304 {
3305 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
3306 }
3307 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3308 {
3309 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
3310 }
3311
3312 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3313
3314 if (data.benchmark == 1)
3315 {
3316 for (u32 i = 0; i < data.benchmark_repeats; i++)
3317 {
3318 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3319 }
3320 }
3321
3322 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3323
3324 if (data.devices_status == STATUS_CRACKED) break;
3325 if (data.devices_status == STATUS_ABORTED) break;
3326 if (data.devices_status == STATUS_QUIT) break;
3327
3328 /**
3329 * result
3330 */
3331
3332 hc_thread_mutex_lock (mux_display);
3333
3334 check_cracked (device_param, salt_pos);
3335
3336 hc_thread_mutex_unlock (mux_display);
3337
3338 /**
3339 * progress
3340 */
3341
3342 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3343
3344 if (data.benchmark == 1)
3345 {
3346 perf_sum_all = (perf_sum_all * data.benchmark_repeats) + perf_sum_all;
3347 }
3348
3349 hc_thread_mutex_lock (mux_counter);
3350
3351 data.words_progress_done[salt_pos] += perf_sum_all;
3352
3353 hc_thread_mutex_unlock (mux_counter);
3354
3355 /**
3356 * speed
3357 */
3358
3359 float speed_ms;
3360
3361 hc_timer_get (device_param->timer_speed, speed_ms);
3362
3363 hc_timer_set (&device_param->timer_speed);
3364
3365 hc_thread_mutex_lock (mux_display);
3366
3367 device_param->speed_cnt[speed_pos] = perf_sum_all;
3368
3369 device_param->speed_ms[speed_pos] = speed_ms;
3370
3371 device_param->speed_rec[speed_pos] = device_param->timer_speed;
3372
3373 hc_thread_mutex_unlock (mux_display);
3374
3375 speed_pos++;
3376
3377 if (speed_pos == SPEED_CACHE)
3378 {
3379 speed_pos = 0;
3380 }
3381
3382 /**
3383 * benchmark
3384 */
3385
3386 if (data.benchmark == 1) break;
3387 }
3388 }
3389
3390 device_param->speed_pos = speed_pos;
3391 }
3392
3393 static void load_segment (wl_data_t *wl_data, FILE *fd)
3394 {
3395 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3396
3397 wl_data->pos = 0;
3398
3399 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3400
3401 wl_data->buf[wl_data->cnt] = 0;
3402
3403 if (wl_data->cnt == 0) return;
3404
3405 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3406
3407 while (!feof (fd))
3408 {
3409 if (wl_data->cnt == wl_data->avail)
3410 {
3411 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3412
3413 wl_data->avail += wl_data->incr;
3414 }
3415
3416 const int c = fgetc (fd);
3417
3418 if (c == EOF) break;
3419
3420 wl_data->buf[wl_data->cnt] = (char) c;
3421
3422 wl_data->cnt++;
3423
3424 if (c == '\n') break;
3425 }
3426
3427 // ensure stream ends with a newline
3428
3429 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3430 {
3431 wl_data->cnt++;
3432
3433 wl_data->buf[wl_data->cnt - 1] = '\n';
3434 }
3435
3436 return;
3437 }
3438
3439 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3440 {
3441 char *ptr = buf;
3442
3443 for (u32 i = 0; i < sz; i++, ptr++)
3444 {
3445 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3446
3447 if (i == 7)
3448 {
3449 *off = i;
3450 *len = i;
3451
3452 return;
3453 }
3454
3455 if (*ptr != '\n') continue;
3456
3457 *off = i + 1;
3458
3459 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3460
3461 *len = i;
3462
3463 return;
3464 }
3465
3466 *off = sz;
3467 *len = sz;
3468 }
3469
3470 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3471 {
3472 char *ptr = buf;
3473
3474 for (u32 i = 0; i < sz; i++, ptr++)
3475 {
3476 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3477
3478 if (*ptr != '\n') continue;
3479
3480 *off = i + 1;
3481
3482 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3483
3484 *len = i;
3485
3486 return;
3487 }
3488
3489 *off = sz;
3490 *len = sz;
3491 }
3492
3493 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3494 {
3495 char *ptr = buf;
3496
3497 for (u32 i = 0; i < sz; i++, ptr++)
3498 {
3499 if (*ptr != '\n') continue;
3500
3501 *off = i + 1;
3502
3503 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3504
3505 *len = i;
3506
3507 return;
3508 }
3509
3510 *off = sz;
3511 *len = sz;
3512 }
3513
3514 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3515 {
3516 while (wl_data->pos < wl_data->cnt)
3517 {
3518 uint off;
3519 uint len;
3520
3521 char *ptr = wl_data->buf + wl_data->pos;
3522
3523 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3524
3525 wl_data->pos += off;
3526
3527 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3528 {
3529 char rule_buf_out[BLOCK_SIZE] = { 0 };
3530
3531 int rule_len_out = -1;
3532
3533 if (len < BLOCK_SIZE)
3534 {
3535 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3536 }
3537
3538 if (rule_len_out < 0)
3539 {
3540 continue;
3541 }
3542
3543 if (rule_len_out > PW_MAX)
3544 {
3545 continue;
3546 }
3547 }
3548 else
3549 {
3550 if (len > PW_MAX)
3551 {
3552 continue;
3553 }
3554 }
3555
3556 *out_buf = ptr;
3557 *out_len = len;
3558
3559 return;
3560 }
3561
3562 if (feof (fd))
3563 {
3564 fprintf (stderr, "BUG feof()!!\n");
3565
3566 return;
3567 }
3568
3569 load_segment (wl_data, fd);
3570
3571 get_next_word (wl_data, fd, out_buf, out_len);
3572 }
3573
3574 #ifdef _POSIX
3575 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3576 #endif
3577
3578 #ifdef _WIN
3579 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3580 #endif
3581 {
3582 hc_signal (NULL);
3583
3584 dictstat_t d;
3585
3586 d.cnt = 0;
3587
3588 #ifdef _POSIX
3589 fstat (fileno (fd), &d.stat);
3590 #endif
3591
3592 #ifdef _WIN
3593 _fstat64 (fileno (fd), &d.stat);
3594 #endif
3595
3596 d.stat.st_mode = 0;
3597 d.stat.st_nlink = 0;
3598 d.stat.st_uid = 0;
3599 d.stat.st_gid = 0;
3600 d.stat.st_rdev = 0;
3601 d.stat.st_atime = 0;
3602
3603 #ifdef _POSIX
3604 d.stat.st_blksize = 0;
3605 d.stat.st_blocks = 0;
3606 #endif
3607
3608 if (d.stat.st_size == 0) return 0;
3609
3610 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3611
3612 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3613 {
3614 if (d_cache)
3615 {
3616 u64 cnt = d_cache->cnt;
3617
3618 u64 keyspace = cnt;
3619
3620 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3621 {
3622 keyspace *= data.kernel_rules_cnt;
3623 }
3624 else if (data.attack_kern == ATTACK_KERN_COMBI)
3625 {
3626 keyspace *= data.combs_cnt;
3627 }
3628
3629 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);
3630 if (data.quiet == 0) log_info ("");
3631
3632 hc_signal (sigHandler_default);
3633
3634 return (keyspace);
3635 }
3636 }
3637
3638 time_t now = 0;
3639 time_t prev = 0;
3640
3641 u64 comp = 0;
3642 u64 cnt = 0;
3643 u64 cnt2 = 0;
3644
3645 while (!feof (fd))
3646 {
3647 load_segment (wl_data, fd);
3648
3649 comp += wl_data->cnt;
3650
3651 u32 i = 0;
3652
3653 while (i < wl_data->cnt)
3654 {
3655 u32 len;
3656 u32 off;
3657
3658 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3659
3660 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3661 {
3662 char rule_buf_out[BLOCK_SIZE] = { 0 };
3663
3664 int rule_len_out = -1;
3665
3666 if (len < BLOCK_SIZE)
3667 {
3668 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3669 }
3670
3671 if (rule_len_out < 0)
3672 {
3673 len = PW_MAX1;
3674 }
3675 else
3676 {
3677 len = rule_len_out;
3678 }
3679 }
3680
3681 if (len < PW_MAX1)
3682 {
3683 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3684 {
3685 cnt += data.kernel_rules_cnt;
3686 }
3687 else if (data.attack_kern == ATTACK_KERN_COMBI)
3688 {
3689 cnt += data.combs_cnt;
3690 }
3691
3692 d.cnt++;
3693 }
3694
3695 i += off;
3696
3697 cnt2++;
3698 }
3699
3700 time (&now);
3701
3702 if ((now - prev) == 0) continue;
3703
3704 float percent = (float) comp / (float) d.stat.st_size;
3705
3706 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);
3707
3708 time (&prev);
3709 }
3710
3711 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);
3712 if (data.quiet == 0) log_info ("");
3713
3714 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3715
3716 hc_signal (sigHandler_default);
3717
3718 return (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 void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4286 {
4287 if (device_param->pws_cnt < device_param->kernel_power)
4288 {
4289 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4290
4291 u8 *ptr = (u8 *) pw->i;
4292
4293 memcpy (ptr, pw_buf, pw_len);
4294
4295 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4296
4297 pw->pw_len = pw_len;
4298
4299 device_param->pws_cnt++;
4300 }
4301 else
4302 {
4303 fprintf (stderr, "BUG pw_add()!!\n");
4304
4305 return;
4306 }
4307 }
4308
4309 static uint get_work (hc_device_param_t *device_param, const u64 max, const bool allow_div)
4310 {
4311 hc_thread_mutex_lock (mux_dispatcher);
4312
4313 const u64 words_cur = data.words_cur;
4314 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4315
4316 device_param->words_off = words_cur;
4317
4318 const u64 words_left = words_base - words_cur;
4319
4320 if (allow_div)
4321 {
4322 if (data.kernel_power_all > words_left)
4323 {
4324 if (data.kernel_power_div == 0)
4325 {
4326 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4327 }
4328 }
4329
4330 if (data.kernel_power_div)
4331 {
4332 if (device_param->kernel_power == device_param->kernel_power_user)
4333 {
4334 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4335
4336 if (kernel_power_new < device_param->kernel_power)
4337 {
4338 device_param->kernel_power = kernel_power_new;
4339 }
4340 }
4341 }
4342 }
4343
4344 const uint kernel_power = device_param->kernel_power;
4345
4346 uint work = MIN (words_left, kernel_power);
4347
4348 work = MIN (work, max);
4349
4350 data.words_cur += work;
4351
4352 hc_thread_mutex_unlock (mux_dispatcher);
4353
4354 return work;
4355 }
4356
4357 static void *thread_calc_stdin (void *p)
4358 {
4359 hc_device_param_t *device_param = (hc_device_param_t *) p;
4360
4361 if (device_param->skipped) return NULL;
4362
4363 autotune (device_param);
4364
4365 const uint attack_kern = data.attack_kern;
4366
4367 const uint kernel_power = device_param->kernel_power;
4368
4369 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4370 {
4371 hc_thread_mutex_lock (mux_dispatcher);
4372
4373 if (feof (stdin) != 0)
4374 {
4375 hc_thread_mutex_unlock (mux_dispatcher);
4376
4377 break;
4378 }
4379
4380 uint words_cur = 0;
4381
4382 while (words_cur < kernel_power)
4383 {
4384 char buf[BUFSIZ] = { 0 };
4385
4386 char *line_buf = fgets (buf, sizeof (buf), stdin);
4387
4388 if (line_buf == NULL) break;
4389
4390 uint line_len = in_superchop (line_buf);
4391
4392 line_len = convert_from_hex (line_buf, line_len);
4393
4394 // post-process rule engine
4395
4396 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4397 {
4398 char rule_buf_out[BLOCK_SIZE] = { 0 };
4399
4400 int rule_len_out = -1;
4401
4402 if (line_len < BLOCK_SIZE)
4403 {
4404 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4405 }
4406
4407 if (rule_len_out < 0) continue;
4408
4409 line_buf = rule_buf_out;
4410 line_len = rule_len_out;
4411 }
4412
4413 if (line_len > PW_MAX)
4414 {
4415 continue;
4416 }
4417
4418 if (attack_kern == ATTACK_KERN_STRAIGHT)
4419 {
4420 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4421 {
4422 hc_thread_mutex_lock (mux_counter);
4423
4424 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4425 {
4426 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4427 }
4428
4429 hc_thread_mutex_unlock (mux_counter);
4430
4431 continue;
4432 }
4433 }
4434 else if (attack_kern == ATTACK_KERN_COMBI)
4435 {
4436 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4437 // since we still need to combine the plains
4438
4439 if (line_len > data.pw_max)
4440 {
4441 hc_thread_mutex_lock (mux_counter);
4442
4443 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4444 {
4445 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4446 }
4447
4448 hc_thread_mutex_unlock (mux_counter);
4449
4450 continue;
4451 }
4452 }
4453
4454 pw_add (device_param, (u8 *) line_buf, line_len);
4455
4456 words_cur++;
4457
4458 if (data.devices_status == STATUS_CRACKED) break;
4459 if (data.devices_status == STATUS_ABORTED) break;
4460 if (data.devices_status == STATUS_QUIT) break;
4461 if (data.devices_status == STATUS_BYPASS) break;
4462 }
4463
4464 hc_thread_mutex_unlock (mux_dispatcher);
4465
4466 if (data.devices_status == STATUS_CRACKED) break;
4467 if (data.devices_status == STATUS_ABORTED) break;
4468 if (data.devices_status == STATUS_QUIT) break;
4469 if (data.devices_status == STATUS_BYPASS) break;
4470
4471 // flush
4472
4473 const uint pws_cnt = device_param->pws_cnt;
4474
4475 if (pws_cnt)
4476 {
4477 run_copy (device_param, pws_cnt);
4478
4479 run_cracker (device_param, pws_cnt);
4480
4481 device_param->pws_cnt = 0;
4482
4483 if (attack_kern == ATTACK_KERN_STRAIGHT)
4484 {
4485 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4486 }
4487 else if (attack_kern == ATTACK_KERN_COMBI)
4488 {
4489 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4490 }
4491 }
4492 }
4493
4494 device_param->kernel_accel = 0;
4495 device_param->kernel_loops = 0;
4496
4497 return NULL;
4498 }
4499
4500 static void *thread_calc (void *p)
4501 {
4502 hc_device_param_t *device_param = (hc_device_param_t *) p;
4503
4504 if (device_param->skipped) return NULL;
4505
4506 autotune (device_param);
4507
4508 const uint attack_mode = data.attack_mode;
4509 const uint attack_kern = data.attack_kern;
4510
4511 if (attack_mode == ATTACK_MODE_BF)
4512 {
4513 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4514 {
4515 const uint work = get_work (device_param, -1, true);
4516
4517 if (work == 0) break;
4518
4519 const u64 words_off = device_param->words_off;
4520 const u64 words_fin = words_off + work;
4521
4522 const uint pws_cnt = work;
4523
4524 device_param->pws_cnt = pws_cnt;
4525
4526 if (pws_cnt)
4527 {
4528 run_copy (device_param, pws_cnt);
4529
4530 run_cracker (device_param, pws_cnt);
4531
4532 device_param->pws_cnt = 0;
4533
4534 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4535 }
4536
4537 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4538
4539 if (data.devices_status == STATUS_CRACKED) break;
4540 if (data.devices_status == STATUS_ABORTED) break;
4541 if (data.devices_status == STATUS_QUIT) break;
4542 if (data.devices_status == STATUS_BYPASS) break;
4543
4544 if (data.benchmark == 1) break;
4545
4546 device_param->words_done = words_fin;
4547 }
4548 }
4549 else
4550 {
4551 const uint segment_size = data.segment_size;
4552
4553 char *dictfile = data.dictfile;
4554
4555 if (attack_mode == ATTACK_MODE_COMBI)
4556 {
4557 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4558 {
4559 dictfile = data.dictfile2;
4560 }
4561 }
4562
4563 FILE *fd = fopen (dictfile, "rb");
4564
4565 if (fd == NULL)
4566 {
4567 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4568
4569 return NULL;
4570 }
4571
4572 if (attack_mode == ATTACK_MODE_COMBI)
4573 {
4574 const uint combs_mode = data.combs_mode;
4575
4576 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4577 {
4578 const char *dictfilec = data.dictfile2;
4579
4580 FILE *combs_fp = fopen (dictfilec, "rb");
4581
4582 if (combs_fp == NULL)
4583 {
4584 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4585
4586 fclose (fd);
4587
4588 return NULL;
4589 }
4590
4591 device_param->combs_fp = combs_fp;
4592 }
4593 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4594 {
4595 const char *dictfilec = data.dictfile;
4596
4597 FILE *combs_fp = fopen (dictfilec, "rb");
4598
4599 if (combs_fp == NULL)
4600 {
4601 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4602
4603 fclose (fd);
4604
4605 return NULL;
4606 }
4607
4608 device_param->combs_fp = combs_fp;
4609 }
4610 }
4611
4612 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4613
4614 wl_data->buf = (char *) mymalloc (segment_size);
4615 wl_data->avail = segment_size;
4616 wl_data->incr = segment_size;
4617 wl_data->cnt = 0;
4618 wl_data->pos = 0;
4619
4620 u64 words_cur = 0;
4621
4622 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4623 {
4624 u64 words_off = 0;
4625 u64 words_fin = 0;
4626
4627 bool allow_div = true;
4628
4629 u64 max = -1;
4630
4631 while (max)
4632 {
4633 const uint work = get_work (device_param, max, allow_div);
4634
4635 allow_div = false;
4636
4637 if (work == 0) break;
4638
4639 words_off = device_param->words_off;
4640 words_fin = words_off + work;
4641
4642 char *line_buf;
4643 uint line_len;
4644
4645 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4646
4647 max = 0;
4648
4649 for ( ; words_cur < words_fin; words_cur++)
4650 {
4651 get_next_word (wl_data, fd, &line_buf, &line_len);
4652
4653 line_len = convert_from_hex (line_buf, line_len);
4654
4655 // post-process rule engine
4656
4657 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4658 {
4659 char rule_buf_out[BLOCK_SIZE] = { 0 };
4660
4661 int rule_len_out = -1;
4662
4663 if (line_len < BLOCK_SIZE)
4664 {
4665 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4666 }
4667
4668 if (rule_len_out < 0) continue;
4669
4670 line_buf = rule_buf_out;
4671 line_len = rule_len_out;
4672 }
4673
4674 if (attack_kern == ATTACK_KERN_STRAIGHT)
4675 {
4676 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4677 {
4678 max++;
4679
4680 hc_thread_mutex_lock (mux_counter);
4681
4682 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4683 {
4684 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4685 }
4686
4687 hc_thread_mutex_unlock (mux_counter);
4688
4689 continue;
4690 }
4691 }
4692 else if (attack_kern == ATTACK_KERN_COMBI)
4693 {
4694 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4695 // since we still need to combine the plains
4696
4697 if (line_len > data.pw_max)
4698 {
4699 max++;
4700
4701 hc_thread_mutex_lock (mux_counter);
4702
4703 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4704 {
4705 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4706 }
4707
4708 hc_thread_mutex_unlock (mux_counter);
4709
4710 continue;
4711 }
4712 }
4713
4714 pw_add (device_param, (u8 *) line_buf, line_len);
4715
4716 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4717
4718 if (data.devices_status == STATUS_CRACKED) break;
4719 if (data.devices_status == STATUS_ABORTED) break;
4720 if (data.devices_status == STATUS_QUIT) break;
4721 if (data.devices_status == STATUS_BYPASS) break;
4722 }
4723
4724 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4725
4726 if (data.devices_status == STATUS_CRACKED) break;
4727 if (data.devices_status == STATUS_ABORTED) break;
4728 if (data.devices_status == STATUS_QUIT) break;
4729 if (data.devices_status == STATUS_BYPASS) break;
4730 }
4731
4732 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4733
4734 if (data.devices_status == STATUS_CRACKED) break;
4735 if (data.devices_status == STATUS_ABORTED) break;
4736 if (data.devices_status == STATUS_QUIT) break;
4737 if (data.devices_status == STATUS_BYPASS) break;
4738
4739 //
4740 // flush
4741 //
4742
4743 const uint pws_cnt = device_param->pws_cnt;
4744
4745 if (pws_cnt)
4746 {
4747 run_copy (device_param, pws_cnt);
4748
4749 run_cracker (device_param, pws_cnt);
4750
4751 device_param->pws_cnt = 0;
4752
4753 if (attack_kern == ATTACK_KERN_STRAIGHT)
4754 {
4755 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4756 }
4757 else if (attack_kern == ATTACK_KERN_COMBI)
4758 {
4759 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4760 }
4761 }
4762
4763 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4764
4765 if (data.devices_status == STATUS_CRACKED) break;
4766 if (data.devices_status == STATUS_ABORTED) break;
4767 if (data.devices_status == STATUS_QUIT) break;
4768 if (data.devices_status == STATUS_BYPASS) break;
4769
4770 if (words_fin == 0) break;
4771
4772 device_param->words_done = words_fin;
4773 }
4774
4775 if (attack_mode == ATTACK_MODE_COMBI)
4776 {
4777 fclose (device_param->combs_fp);
4778 }
4779
4780 free (wl_data->buf);
4781 free (wl_data);
4782
4783 fclose (fd);
4784 }
4785
4786 device_param->kernel_accel = 0;
4787 device_param->kernel_loops = 0;
4788
4789 return NULL;
4790 }
4791
4792 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4793 {
4794 if (!device_param)
4795 {
4796 log_error ("ERROR: %s : Invalid argument", __func__);
4797
4798 exit (-1);
4799 }
4800
4801 salt_t *salt_buf = &data.salts_buf[salt_pos];
4802
4803 device_param->kernel_params_buf32[24] = salt_pos;
4804 device_param->kernel_params_buf32[27] = 1;
4805 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4806 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4807 device_param->kernel_params_buf32[30] = 0;
4808 device_param->kernel_params_buf32[31] = 1;
4809
4810 char *dictfile_old = data.dictfile;
4811
4812 const char *weak_hash_check = "weak-hash-check";
4813
4814 data.dictfile = (char *) weak_hash_check;
4815
4816 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4817
4818 data.kernel_rules_buf[0].cmds[0] = 0;
4819
4820 /**
4821 * run the kernel
4822 */
4823
4824 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4825 {
4826 run_kernel (KERN_RUN_1, device_param, 1, false);
4827 }
4828 else
4829 {
4830 run_kernel (KERN_RUN_1, device_param, 1, false);
4831
4832 uint loop_step = 16;
4833
4834 const uint iter = salt_buf->salt_iter;
4835
4836 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4837 {
4838 uint loop_left = iter - loop_pos;
4839
4840 loop_left = MIN (loop_left, loop_step);
4841
4842 device_param->kernel_params_buf32[25] = loop_pos;
4843 device_param->kernel_params_buf32[26] = loop_left;
4844
4845 run_kernel (KERN_RUN_2, device_param, 1, false);
4846 }
4847
4848 run_kernel (KERN_RUN_3, device_param, 1, false);
4849 }
4850
4851 /**
4852 * result
4853 */
4854
4855 check_cracked (device_param, salt_pos);
4856
4857 /**
4858 * cleanup
4859 */
4860
4861 device_param->kernel_params_buf32[24] = 0;
4862 device_param->kernel_params_buf32[25] = 0;
4863 device_param->kernel_params_buf32[26] = 0;
4864 device_param->kernel_params_buf32[27] = 0;
4865 device_param->kernel_params_buf32[28] = 0;
4866 device_param->kernel_params_buf32[29] = 0;
4867 device_param->kernel_params_buf32[30] = 0;
4868 device_param->kernel_params_buf32[31] = 0;
4869
4870 data.dictfile = dictfile_old;
4871
4872 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4873 }
4874
4875 // hlfmt hashcat
4876
4877 static void hlfmt_hash_hashcat (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4878 {
4879 if (data.username == 0)
4880 {
4881 *hashbuf_pos = line_buf;
4882 *hashbuf_len = line_len;
4883 }
4884 else
4885 {
4886 char *pos = line_buf;
4887 int len = line_len;
4888
4889 for (int i = 0; i < line_len; i++, pos++, len--)
4890 {
4891 if (line_buf[i] == data.separator)
4892 {
4893 pos++;
4894
4895 len--;
4896
4897 break;
4898 }
4899 }
4900
4901 *hashbuf_pos = pos;
4902 *hashbuf_len = len;
4903 }
4904 }
4905
4906 static void hlfmt_user_hashcat (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4907 {
4908 char *pos = NULL;
4909 int len = 0;
4910
4911 int sep_cnt = 0;
4912
4913 for (int i = 0; i < line_len; i++)
4914 {
4915 if (line_buf[i] == data.separator)
4916 {
4917 sep_cnt++;
4918
4919 continue;
4920 }
4921
4922 if (sep_cnt == 0)
4923 {
4924 if (pos == NULL) pos = line_buf + i;
4925
4926 len++;
4927 }
4928 }
4929
4930 *userbuf_pos = pos;
4931 *userbuf_len = len;
4932 }
4933
4934 // hlfmt pwdump
4935
4936 static int hlfmt_detect_pwdump (char line_buf[BUFSIZ], int line_len)
4937 {
4938 int sep_cnt = 0;
4939
4940 int sep2_len = 0;
4941 int sep3_len = 0;
4942
4943 for (int i = 0; i < line_len; i++)
4944 {
4945 if (line_buf[i] == ':')
4946 {
4947 sep_cnt++;
4948
4949 continue;
4950 }
4951
4952 if (sep_cnt == 2) sep2_len++;
4953 if (sep_cnt == 3) sep3_len++;
4954 }
4955
4956 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4957
4958 return 0;
4959 }
4960
4961 static void hlfmt_hash_pwdump (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4962 {
4963 char *pos = NULL;
4964 int len = 0;
4965
4966 int sep_cnt = 0;
4967
4968 for (int i = 0; i < line_len; i++)
4969 {
4970 if (line_buf[i] == ':')
4971 {
4972 sep_cnt++;
4973
4974 continue;
4975 }
4976
4977 if (data.hash_mode == 1000)
4978 {
4979 if (sep_cnt == 3)
4980 {
4981 if (pos == NULL) pos = line_buf + i;
4982
4983 len++;
4984 }
4985 }
4986 else if (data.hash_mode == 3000)
4987 {
4988 if (sep_cnt == 2)
4989 {
4990 if (pos == NULL) pos = line_buf + i;
4991
4992 len++;
4993 }
4994 }
4995 }
4996
4997 *hashbuf_pos = pos;
4998 *hashbuf_len = len;
4999 }
5000
5001 static void hlfmt_user_pwdump (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5002 {
5003 char *pos = NULL;
5004 int len = 0;
5005
5006 int sep_cnt = 0;
5007
5008 for (int i = 0; i < line_len; i++)
5009 {
5010 if (line_buf[i] == ':')
5011 {
5012 sep_cnt++;
5013
5014 continue;
5015 }
5016
5017 if (sep_cnt == 0)
5018 {
5019 if (pos == NULL) pos = line_buf + i;
5020
5021 len++;
5022 }
5023 }
5024
5025 *userbuf_pos = pos;
5026 *userbuf_len = len;
5027 }
5028
5029 // hlfmt passwd
5030
5031 static int hlfmt_detect_passwd (char line_buf[BUFSIZ], int line_len)
5032 {
5033 int sep_cnt = 0;
5034
5035 char sep5_first = 0;
5036 char sep6_first = 0;
5037
5038 for (int i = 0; i < line_len; i++)
5039 {
5040 if (line_buf[i] == ':')
5041 {
5042 sep_cnt++;
5043
5044 continue;
5045 }
5046
5047 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5048 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5049 }
5050
5051 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5052
5053 return 0;
5054 }
5055
5056 static void hlfmt_hash_passwd (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5057 {
5058 char *pos = NULL;
5059 int len = 0;
5060
5061 int sep_cnt = 0;
5062
5063 for (int i = 0; i < line_len; i++)
5064 {
5065 if (line_buf[i] == ':')
5066 {
5067 sep_cnt++;
5068
5069 continue;
5070 }
5071
5072 if (sep_cnt == 1)
5073 {
5074 if (pos == NULL) pos = line_buf + i;
5075
5076 len++;
5077 }
5078 }
5079
5080 *hashbuf_pos = pos;
5081 *hashbuf_len = len;
5082 }
5083
5084 static void hlfmt_user_passwd (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5085 {
5086 char *pos = NULL;
5087 int len = 0;
5088
5089 int sep_cnt = 0;
5090
5091 for (int i = 0; i < line_len; i++)
5092 {
5093 if (line_buf[i] == ':')
5094 {
5095 sep_cnt++;
5096
5097 continue;
5098 }
5099
5100 if (sep_cnt == 0)
5101 {
5102 if (pos == NULL) pos = line_buf + i;
5103
5104 len++;
5105 }
5106 }
5107
5108 *userbuf_pos = pos;
5109 *userbuf_len = len;
5110 }
5111
5112 // hlfmt shadow
5113
5114 static int hlfmt_detect_shadow (char line_buf[BUFSIZ], int line_len)
5115 {
5116 int sep_cnt = 0;
5117
5118 for (int i = 0; i < line_len; i++)
5119 {
5120 if (line_buf[i] == ':') sep_cnt++;
5121 }
5122
5123 if (sep_cnt == 8) return 1;
5124
5125 return 0;
5126 }
5127
5128 static void hlfmt_hash_shadow (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5129 {
5130 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5131 }
5132
5133 static void hlfmt_user_shadow (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5134 {
5135 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5136 }
5137
5138 // hlfmt main
5139
5140 static void hlfmt_hash (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5141 {
5142 switch (hashfile_format)
5143 {
5144 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5145 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5146 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5147 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5148 }
5149 }
5150
5151 static void hlfmt_user (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5152 {
5153 switch (hashfile_format)
5154 {
5155 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5156 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5157 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5158 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5159 }
5160 }
5161
5162 char *strhlfmt (const uint hashfile_format)
5163 {
5164 switch (hashfile_format)
5165 {
5166 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5167 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5168 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5169 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5170 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5171 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5172 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5173 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5174 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5175 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5176 }
5177
5178 return ((char *) "Unknown");
5179 }
5180
5181 static uint hlfmt_detect (FILE *fp, uint max_check)
5182 {
5183 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5184
5185 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5186 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5187
5188 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5189
5190 uint num_check = 0;
5191
5192 while (!feof (fp))
5193 {
5194 char line_buf[BUFSIZ] = { 0 };
5195
5196 int line_len = fgetl (fp, line_buf);
5197
5198 if (line_len == 0) continue;
5199
5200 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5201 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5202 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5203
5204 if (num_check == max_check) break;
5205
5206 num_check++;
5207 }
5208
5209 uint hashlist_format = HLFMT_HASHCAT;
5210
5211 for (int i = 1; i < HLFMTS_CNT; i++)
5212 {
5213 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5214
5215 hashlist_format = i;
5216 }
5217
5218 free (formats_cnt);
5219
5220 return hashlist_format;
5221 }
5222
5223 /**
5224 * some further helper function
5225 */
5226
5227 // wrapper around mymalloc for ADL
5228
5229 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5230 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5231 {
5232 return mymalloc (iSize);
5233 }
5234 #endif
5235
5236 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)
5237 {
5238 u64 collisions = 0;
5239
5240 const uint dgst_pos0 = data.dgst_pos0;
5241 const uint dgst_pos1 = data.dgst_pos1;
5242 const uint dgst_pos2 = data.dgst_pos2;
5243 const uint dgst_pos3 = data.dgst_pos3;
5244
5245 memset (bitmap_a, 0, bitmap_size);
5246 memset (bitmap_b, 0, bitmap_size);
5247 memset (bitmap_c, 0, bitmap_size);
5248 memset (bitmap_d, 0, bitmap_size);
5249
5250 for (uint i = 0; i < digests_cnt; i++)
5251 {
5252 uint *digest_ptr = (uint *) digests_buf_ptr;
5253
5254 digests_buf_ptr += dgst_size;
5255
5256 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5257 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5258 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5259 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5260
5261 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5262 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5263 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5264 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5265
5266 if (bitmap_a[idx0] & val0) collisions++;
5267 if (bitmap_b[idx1] & val1) collisions++;
5268 if (bitmap_c[idx2] & val2) collisions++;
5269 if (bitmap_d[idx3] & val3) collisions++;
5270
5271 bitmap_a[idx0] |= val0;
5272 bitmap_b[idx1] |= val1;
5273 bitmap_c[idx2] |= val2;
5274 bitmap_d[idx3] |= val3;
5275
5276 if (collisions >= collisions_max) return 0x7fffffff;
5277 }
5278
5279 return collisions;
5280 }
5281
5282 /**
5283 * main
5284 */
5285
5286 int main (int argc, char **argv)
5287 {
5288 /**
5289 * To help users a bit
5290 */
5291
5292 char *compute = getenv ("COMPUTE");
5293
5294 if (compute)
5295 {
5296 static char display[100];
5297
5298 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5299
5300 putenv (display);
5301 }
5302 else
5303 {
5304 if (getenv ("DISPLAY") == NULL)
5305 putenv ((char *) "DISPLAY=:0");
5306 }
5307
5308 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5309 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5310
5311 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5312 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5313
5314 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5315 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5316
5317 /**
5318 * Real init
5319 */
5320
5321 memset (&data, 0, sizeof (hc_global_data_t));
5322
5323 time_t proc_start;
5324
5325 time (&proc_start);
5326
5327 data.proc_start = proc_start;
5328
5329 int myargc = argc;
5330 char **myargv = argv;
5331
5332 hc_thread_mutex_init (mux_dispatcher);
5333 hc_thread_mutex_init (mux_counter);
5334 hc_thread_mutex_init (mux_display);
5335 hc_thread_mutex_init (mux_adl);
5336
5337 /**
5338 * commandline parameters
5339 */
5340
5341 uint usage = USAGE;
5342 uint version = VERSION;
5343 uint quiet = QUIET;
5344 uint benchmark = BENCHMARK;
5345 uint benchmark_repeats = BENCHMARK_REPEATS;
5346 uint show = SHOW;
5347 uint left = LEFT;
5348 uint username = USERNAME;
5349 uint remove = REMOVE;
5350 uint remove_timer = REMOVE_TIMER;
5351 u64 skip = SKIP;
5352 u64 limit = LIMIT;
5353 uint keyspace = KEYSPACE;
5354 uint potfile_disable = POTFILE_DISABLE;
5355 uint debug_mode = DEBUG_MODE;
5356 char *debug_file = NULL;
5357 char *induction_dir = NULL;
5358 char *outfile_check_dir = NULL;
5359 uint force = FORCE;
5360 uint runtime = RUNTIME;
5361 uint hash_mode = HASH_MODE;
5362 uint attack_mode = ATTACK_MODE;
5363 uint markov_disable = MARKOV_DISABLE;
5364 uint markov_classic = MARKOV_CLASSIC;
5365 uint markov_threshold = MARKOV_THRESHOLD;
5366 char *markov_hcstat = NULL;
5367 char *outfile = NULL;
5368 uint outfile_format = OUTFILE_FORMAT;
5369 uint outfile_autohex = OUTFILE_AUTOHEX;
5370 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5371 uint restore = RESTORE;
5372 uint restore_timer = RESTORE_TIMER;
5373 uint restore_disable = RESTORE_DISABLE;
5374 uint status = STATUS;
5375 uint status_timer = STATUS_TIMER;
5376 uint status_automat = STATUS_AUTOMAT;
5377 uint loopback = LOOPBACK;
5378 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5379 char *session = NULL;
5380 uint hex_charset = HEX_CHARSET;
5381 uint hex_salt = HEX_SALT;
5382 uint hex_wordlist = HEX_WORDLIST;
5383 uint rp_gen = RP_GEN;
5384 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5385 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5386 uint rp_gen_seed = RP_GEN_SEED;
5387 char *rule_buf_l = (char *) RULE_BUF_L;
5388 char *rule_buf_r = (char *) RULE_BUF_R;
5389 uint increment = INCREMENT;
5390 uint increment_min = INCREMENT_MIN;
5391 uint increment_max = INCREMENT_MAX;
5392 char *cpu_affinity = NULL;
5393 OCL_PTR *ocl = NULL;
5394 char *opencl_devices = NULL;
5395 char *opencl_platforms = NULL;
5396 char *opencl_device_types = NULL;
5397 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5398 char *truecrypt_keyfiles = NULL;
5399 uint workload_profile = WORKLOAD_PROFILE;
5400 uint kernel_accel = KERNEL_ACCEL;
5401 uint kernel_loops = KERNEL_LOOPS;
5402 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5403 #ifdef HAVE_HWMON
5404 uint gpu_temp_abort = GPU_TEMP_ABORT;
5405 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5406 #ifdef HAVE_ADL
5407 uint powertune_enable = POWERTUNE_ENABLE;
5408 #endif
5409 #endif
5410 uint logfile_disable = LOGFILE_DISABLE;
5411 uint segment_size = SEGMENT_SIZE;
5412 uint scrypt_tmto = SCRYPT_TMTO;
5413 char separator = SEPARATOR;
5414 uint bitmap_min = BITMAP_MIN;
5415 uint bitmap_max = BITMAP_MAX;
5416 char *custom_charset_1 = NULL;
5417 char *custom_charset_2 = NULL;
5418 char *custom_charset_3 = NULL;
5419 char *custom_charset_4 = NULL;
5420
5421 #define IDX_HELP 'h'
5422 #define IDX_VERSION 'V'
5423 #define IDX_VERSION_LOWER 'v'
5424 #define IDX_QUIET 0xff02
5425 #define IDX_SHOW 0xff03
5426 #define IDX_LEFT 0xff04
5427 #define IDX_REMOVE 0xff05
5428 #define IDX_REMOVE_TIMER 0xff37
5429 #define IDX_SKIP 's'
5430 #define IDX_LIMIT 'l'
5431 #define IDX_KEYSPACE 0xff35
5432 #define IDX_POTFILE_DISABLE 0xff06
5433 #define IDX_DEBUG_MODE 0xff43
5434 #define IDX_DEBUG_FILE 0xff44
5435 #define IDX_INDUCTION_DIR 0xff46
5436 #define IDX_OUTFILE_CHECK_DIR 0xff47
5437 #define IDX_USERNAME 0xff07
5438 #define IDX_FORCE 0xff08
5439 #define IDX_RUNTIME 0xff09
5440 #define IDX_BENCHMARK 'b'
5441 #define IDX_BENCHMARK_REPEATS 0xff78
5442 #define IDX_HASH_MODE 'm'
5443 #define IDX_ATTACK_MODE 'a'
5444 #define IDX_RP_FILE 'r'
5445 #define IDX_RP_GEN 'g'
5446 #define IDX_RP_GEN_FUNC_MIN 0xff10
5447 #define IDX_RP_GEN_FUNC_MAX 0xff11
5448 #define IDX_RP_GEN_SEED 0xff34
5449 #define IDX_RULE_BUF_L 'j'
5450 #define IDX_RULE_BUF_R 'k'
5451 #define IDX_INCREMENT 'i'
5452 #define IDX_INCREMENT_MIN 0xff12
5453 #define IDX_INCREMENT_MAX 0xff13
5454 #define IDX_OUTFILE 'o'
5455 #define IDX_OUTFILE_FORMAT 0xff14
5456 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5457 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5458 #define IDX_RESTORE 0xff15
5459 #define IDX_RESTORE_DISABLE 0xff27
5460 #define IDX_STATUS 0xff17
5461 #define IDX_STATUS_TIMER 0xff18
5462 #define IDX_STATUS_AUTOMAT 0xff50
5463 #define IDX_LOOPBACK 0xff38
5464 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5465 #define IDX_SESSION 0xff19
5466 #define IDX_HEX_CHARSET 0xff20
5467 #define IDX_HEX_SALT 0xff21
5468 #define IDX_HEX_WORDLIST 0xff40
5469 #define IDX_MARKOV_DISABLE 0xff22
5470 #define IDX_MARKOV_CLASSIC 0xff23
5471 #define IDX_MARKOV_THRESHOLD 't'
5472 #define IDX_MARKOV_HCSTAT 0xff24
5473 #define IDX_CPU_AFFINITY 0xff25
5474 #define IDX_OPENCL_DEVICES 'd'
5475 #define IDX_OPENCL_PLATFORMS 0xff72
5476 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5477 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5478 #define IDX_WORKLOAD_PROFILE 'w'
5479 #define IDX_KERNEL_ACCEL 'n'
5480 #define IDX_KERNEL_LOOPS 'u'
5481 #define IDX_GPU_TEMP_DISABLE 0xff29
5482 #define IDX_GPU_TEMP_ABORT 0xff30
5483 #define IDX_GPU_TEMP_RETAIN 0xff31
5484 #define IDX_POWERTUNE_ENABLE 0xff41
5485 #define IDX_LOGFILE_DISABLE 0xff51
5486 #define IDX_TRUECRYPT_KEYFILES 0xff52
5487 #define IDX_SCRYPT_TMTO 0xff61
5488 #define IDX_SEGMENT_SIZE 'c'
5489 #define IDX_SEPARATOR 'p'
5490 #define IDX_BITMAP_MIN 0xff70
5491 #define IDX_BITMAP_MAX 0xff71
5492 #define IDX_CUSTOM_CHARSET_1 '1'
5493 #define IDX_CUSTOM_CHARSET_2 '2'
5494 #define IDX_CUSTOM_CHARSET_3 '3'
5495 #define IDX_CUSTOM_CHARSET_4 '4'
5496
5497 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5498
5499 struct option long_options[] =
5500 {
5501 {"help", no_argument, 0, IDX_HELP},
5502 {"version", no_argument, 0, IDX_VERSION},
5503 {"quiet", no_argument, 0, IDX_QUIET},
5504 {"show", no_argument, 0, IDX_SHOW},
5505 {"left", no_argument, 0, IDX_LEFT},
5506 {"username", no_argument, 0, IDX_USERNAME},
5507 {"remove", no_argument, 0, IDX_REMOVE},
5508 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5509 {"skip", required_argument, 0, IDX_SKIP},
5510 {"limit", required_argument, 0, IDX_LIMIT},
5511 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5512 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5513 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5514 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5515 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5516 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5517 {"force", no_argument, 0, IDX_FORCE},
5518 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5519 {"benchmark-repeats", required_argument, 0, IDX_BENCHMARK_REPEATS},
5520 {"restore", no_argument, 0, IDX_RESTORE},
5521 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5522 {"status", no_argument, 0, IDX_STATUS},
5523 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5524 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5525 {"loopback", no_argument, 0, IDX_LOOPBACK},
5526 {"weak-hash-threshold",
5527 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5528 {"session", required_argument, 0, IDX_SESSION},
5529 {"runtime", required_argument, 0, IDX_RUNTIME},
5530 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5531 {"generate-rules-func-min",
5532 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5533 {"generate-rules-func-max",
5534 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5535 {"generate-rules-seed",
5536 required_argument, 0, IDX_RP_GEN_SEED},
5537 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5538 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5539 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5540 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5541 {"rules-file", required_argument, 0, IDX_RP_FILE},
5542 {"outfile", required_argument, 0, IDX_OUTFILE},
5543 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5544 {"outfile-autohex-disable",
5545 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5546 {"outfile-check-timer",
5547 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5548 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5549 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5550 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5551 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5552 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5553 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5554 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5555 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5556 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5557 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5558 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5559 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5560 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5561 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5562 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5563 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5564 #ifdef HAVE_HWMON
5565 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5566 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5567 #ifdef HAVE_ADL
5568 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5569 #endif
5570 #endif // HAVE_HWMON
5571 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5572 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5573 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5574 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5575 // deprecated
5576 {"seperator", required_argument, 0, IDX_SEPARATOR},
5577 {"separator", required_argument, 0, IDX_SEPARATOR},
5578 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5579 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5580 {"increment", no_argument, 0, IDX_INCREMENT},
5581 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5582 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5583 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5584 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5585 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5586 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5587
5588 {0, 0, 0, 0}
5589 };
5590
5591 uint rp_files_cnt = 0;
5592
5593 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5594
5595 int option_index = 0;
5596 int c = -1;
5597
5598 optind = 1;
5599 optopt = 0;
5600
5601 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5602 {
5603 switch (c)
5604 {
5605 case IDX_HELP: usage = 1; break;
5606 case IDX_VERSION:
5607 case IDX_VERSION_LOWER: version = 1; break;
5608 case IDX_RESTORE: restore = 1; break;
5609 case IDX_SESSION: session = optarg; break;
5610 case IDX_SHOW: show = 1; break;
5611 case IDX_LEFT: left = 1; break;
5612 case '?': return (-1);
5613 }
5614 }
5615
5616 if (optopt != 0)
5617 {
5618 log_error ("ERROR: Invalid argument specified");
5619
5620 return (-1);
5621 }
5622
5623 /**
5624 * exit functions
5625 */
5626
5627 if (version)
5628 {
5629 log_info ("%s (%s)", VERSION_TAG, VERSION_SUM);
5630
5631 return (0);
5632 }
5633
5634 if (usage)
5635 {
5636 usage_big_print (PROGNAME);
5637
5638 return (0);
5639 }
5640
5641 /**
5642 * session needs to be set, always!
5643 */
5644
5645 if (session == NULL) session = (char *) PROGNAME;
5646
5647 /**
5648 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5649 */
5650
5651 char *exec_path = get_exec_path ();
5652
5653 #ifdef LINUX
5654
5655 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5656 char *resolved_exec_path = realpath (exec_path, NULL);
5657
5658 char *install_dir = get_install_dir (resolved_exec_path);
5659 char *profile_dir = NULL;
5660 char *session_dir = NULL;
5661 char *shared_dir = NULL;
5662
5663 if (strcmp (install_dir, resolved_install_folder) == 0)
5664 {
5665 struct passwd *pw = getpwuid (getuid ());
5666
5667 const char *homedir = pw->pw_dir;
5668
5669 profile_dir = get_profile_dir (homedir);
5670 session_dir = get_session_dir (profile_dir);
5671 shared_dir = strdup (SHARED_FOLDER);
5672
5673 mkdir (profile_dir, 0700);
5674 mkdir (session_dir, 0700);
5675 }
5676 else
5677 {
5678 profile_dir = install_dir;
5679 session_dir = install_dir;
5680 shared_dir = install_dir;
5681 }
5682
5683 myfree (resolved_install_folder);
5684 myfree (resolved_exec_path);
5685
5686 #else
5687
5688 char *install_dir = get_install_dir (exec_path);
5689 char *profile_dir = install_dir;
5690 char *session_dir = install_dir;
5691 char *shared_dir = install_dir;
5692
5693 #endif
5694
5695 data.install_dir = install_dir;
5696 data.profile_dir = profile_dir;
5697 data.session_dir = session_dir;
5698 data.shared_dir = shared_dir;
5699
5700 myfree (exec_path);
5701
5702 /**
5703 * kernel cache, we need to make sure folder exist
5704 */
5705
5706 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5707
5708 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5709
5710 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5711
5712 mkdir (kernels_folder, 0700);
5713
5714 myfree (kernels_folder);
5715
5716 /**
5717 * session
5718 */
5719
5720 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5721
5722 data.session = session;
5723
5724 char *eff_restore_file = (char *) mymalloc (session_size);
5725 char *new_restore_file = (char *) mymalloc (session_size);
5726
5727 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5728 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5729
5730 data.eff_restore_file = eff_restore_file;
5731 data.new_restore_file = new_restore_file;
5732
5733 if (((show == 1) || (left == 1)) && (restore == 1))
5734 {
5735 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5736 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5737
5738 return (-1);
5739 }
5740
5741 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5742 if ((show == 1) || (left == 1))
5743 {
5744 restore_disable = 1;
5745
5746 restore = 0;
5747 }
5748
5749 data.restore_disable = restore_disable;
5750
5751 restore_data_t *rd = init_restore (argc, argv);
5752
5753 data.rd = rd;
5754
5755 /**
5756 * restore file
5757 */
5758
5759 if (restore == 1)
5760 {
5761 read_restore (eff_restore_file, rd);
5762
5763 if (rd->version_bin < RESTORE_MIN)
5764 {
5765 log_error ("ERROR: Incompatible restore-file version");
5766
5767 return (-1);
5768 }
5769
5770 myargc = rd->argc;
5771 myargv = rd->argv;
5772
5773 #ifdef _POSIX
5774 rd->pid = getpid ();
5775 #elif _WIN
5776 rd->pid = GetCurrentProcessId ();
5777 #endif
5778 }
5779
5780 uint hash_mode_chgd = 0;
5781 uint runtime_chgd = 0;
5782 uint kernel_loops_chgd = 0;
5783 uint kernel_accel_chgd = 0;
5784 uint attack_mode_chgd = 0;
5785 uint outfile_format_chgd = 0;
5786 uint rp_gen_seed_chgd = 0;
5787 uint remove_timer_chgd = 0;
5788 uint increment_min_chgd = 0;
5789 uint increment_max_chgd = 0;
5790 uint workload_profile_chgd = 0;
5791 uint opencl_vector_width_chgd = 0;
5792
5793 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5794 uint gpu_temp_retain_chgd = 0;
5795 uint gpu_temp_abort_chgd = 0;
5796 #endif
5797
5798 optind = 1;
5799 optopt = 0;
5800 option_index = 0;
5801
5802 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5803 {
5804 switch (c)
5805 {
5806 //case IDX_HELP: usage = 1; break;
5807 //case IDX_VERSION: version = 1; break;
5808 //case IDX_RESTORE: restore = 1; break;
5809 case IDX_QUIET: quiet = 1; break;
5810 //case IDX_SHOW: show = 1; break;
5811 case IDX_SHOW: break;
5812 //case IDX_LEFT: left = 1; break;
5813 case IDX_LEFT: break;
5814 case IDX_USERNAME: username = 1; break;
5815 case IDX_REMOVE: remove = 1; break;
5816 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5817 remove_timer_chgd = 1; break;
5818 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5819 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5820 case IDX_DEBUG_FILE: debug_file = optarg; break;
5821 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5822 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5823 case IDX_FORCE: force = 1; break;
5824 case IDX_SKIP: skip = atoll (optarg); break;
5825 case IDX_LIMIT: limit = atoll (optarg); break;
5826 case IDX_KEYSPACE: keyspace = 1; break;
5827 case IDX_BENCHMARK: benchmark = 1; break;
5828 case IDX_BENCHMARK_REPEATS: benchmark_repeats = atoi (optarg); break;
5829 case IDX_RESTORE: break;
5830 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5831 case IDX_STATUS: status = 1; break;
5832 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5833 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5834 case IDX_LOOPBACK: loopback = 1; break;
5835 case IDX_WEAK_HASH_THRESHOLD:
5836 weak_hash_threshold = atoi (optarg); break;
5837 //case IDX_SESSION: session = optarg; break;
5838 case IDX_SESSION: break;
5839 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5840 hash_mode_chgd = 1; break;
5841 case IDX_RUNTIME: runtime = atoi (optarg);
5842 runtime_chgd = 1; break;
5843 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5844 attack_mode_chgd = 1; break;
5845 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5846 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5847 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5848 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5849 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5850 rp_gen_seed_chgd = 1; break;
5851 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5852 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5853 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5854 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5855 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5856 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5857 case IDX_OUTFILE: outfile = optarg; break;
5858 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5859 outfile_format_chgd = 1; break;
5860 case IDX_OUTFILE_AUTOHEX_DISABLE:
5861 outfile_autohex = 0; break;
5862 case IDX_OUTFILE_CHECK_TIMER:
5863 outfile_check_timer = atoi (optarg); break;
5864 case IDX_HEX_CHARSET: hex_charset = 1; break;
5865 case IDX_HEX_SALT: hex_salt = 1; break;
5866 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5867 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5868 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5869 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5870 case IDX_OPENCL_DEVICE_TYPES:
5871 opencl_device_types = optarg; break;
5872 case IDX_OPENCL_VECTOR_WIDTH:
5873 opencl_vector_width = atoi (optarg);
5874 opencl_vector_width_chgd = 1; break;
5875 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
5876 workload_profile_chgd = 1; break;
5877 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5878 kernel_accel_chgd = 1; break;
5879 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5880 kernel_loops_chgd = 1; break;
5881 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5882 #ifdef HAVE_HWMON
5883 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5884 #ifdef HAVE_ADL
5885 gpu_temp_abort_chgd = 1;
5886 #endif
5887 break;
5888 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5889 #ifdef HAVE_ADL
5890 gpu_temp_retain_chgd = 1;
5891 #endif
5892 break;
5893 #ifdef HAVE_ADL
5894 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5895 #endif
5896 #endif // HAVE_HWMON
5897 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5898 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5899 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5900 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5901 case IDX_SEPARATOR: separator = optarg[0]; break;
5902 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5903 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5904 case IDX_INCREMENT: increment = 1; break;
5905 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5906 increment_min_chgd = 1; break;
5907 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5908 increment_max_chgd = 1; break;
5909 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5910 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5911 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5912 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5913
5914 default:
5915 log_error ("ERROR: Invalid argument specified");
5916 return (-1);
5917 }
5918 }
5919
5920 if (optopt != 0)
5921 {
5922 log_error ("ERROR: Invalid argument specified");
5923
5924 return (-1);
5925 }
5926
5927 /**
5928 * Inform user things getting started,
5929 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5930 * - we do not need to check algorithm_pos
5931 */
5932
5933 if (quiet == 0)
5934 {
5935 if (benchmark == 1)
5936 {
5937 log_info ("%s %s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5938
5939 log_info ("");
5940 }
5941 else if (restore == 1)
5942 {
5943 log_info ("%s %s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5944
5945 log_info ("");
5946 }
5947 else
5948 {
5949 log_info ("%s %s (%s) starting...", PROGNAME, VERSION_TAG, VERSION_SUM);
5950
5951 log_info ("");
5952 }
5953 }
5954
5955 /**
5956 * sanity check
5957 */
5958
5959 if (attack_mode > 7)
5960 {
5961 log_error ("ERROR: Invalid attack-mode specified");
5962
5963 return (-1);
5964 }
5965
5966 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5967 {
5968 log_error ("ERROR: Invalid runtime specified");
5969
5970 return (-1);
5971 }
5972
5973 if (hash_mode_chgd && hash_mode > 13300) // just added to remove compiler warnings for hash_mode_chgd
5974 {
5975 log_error ("ERROR: Invalid hash-type specified");
5976
5977 return (-1);
5978 }
5979
5980 // renamed hash modes
5981
5982 if (hash_mode_chgd)
5983 {
5984 int n = -1;
5985
5986 switch (hash_mode)
5987 {
5988 case 123: n = 124;
5989 break;
5990 }
5991
5992 if (n >= 0)
5993 {
5994 log_error ("Old -m specified, use -m %d instead", n);
5995
5996 return (-1);
5997 }
5998 }
5999
6000 if (username == 1)
6001 {
6002 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
6003 {
6004 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6005
6006 return (-1);
6007 }
6008 }
6009
6010 if (outfile_format > 16)
6011 {
6012 log_error ("ERROR: Invalid outfile-format specified");
6013
6014 return (-1);
6015 }
6016
6017 if (left == 1)
6018 {
6019 if (outfile_format_chgd == 1)
6020 {
6021 if (outfile_format > 1)
6022 {
6023 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6024
6025 return (-1);
6026 }
6027 }
6028 else
6029 {
6030 outfile_format = OUTFILE_FMT_HASH;
6031 }
6032 }
6033
6034 if (show == 1)
6035 {
6036 if (outfile_format_chgd == 1)
6037 {
6038 if ((outfile_format > 7) && (outfile_format < 16))
6039 {
6040 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6041
6042 return (-1);
6043 }
6044 }
6045 }
6046
6047 if (increment_min < INCREMENT_MIN)
6048 {
6049 log_error ("ERROR: Invalid increment-min specified");
6050
6051 return (-1);
6052 }
6053
6054 if (increment_max > INCREMENT_MAX)
6055 {
6056 log_error ("ERROR: Invalid increment-max specified");
6057
6058 return (-1);
6059 }
6060
6061 if (increment_min > increment_max)
6062 {
6063 log_error ("ERROR: Invalid increment-min specified");
6064
6065 return (-1);
6066 }
6067
6068 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6069 {
6070 log_error ("ERROR: increment is not allowed in attack-mode 0");
6071
6072 return (-1);
6073 }
6074
6075 if ((increment == 0) && (increment_min_chgd == 1))
6076 {
6077 log_error ("ERROR: increment-min is only supported together with increment switch");
6078
6079 return (-1);
6080 }
6081
6082 if ((increment == 0) && (increment_max_chgd == 1))
6083 {
6084 log_error ("ERROR: increment-max is only supported together with increment switch");
6085
6086 return (-1);
6087 }
6088
6089 if (rp_files_cnt && rp_gen)
6090 {
6091 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6092
6093 return (-1);
6094 }
6095
6096 if (rp_files_cnt || rp_gen)
6097 {
6098 if (attack_mode != ATTACK_MODE_STRAIGHT)
6099 {
6100 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6101
6102 return (-1);
6103 }
6104 }
6105
6106 if (rp_gen_func_min > rp_gen_func_max)
6107 {
6108 log_error ("ERROR: Invalid rp-gen-func-min specified");
6109
6110 return (-1);
6111 }
6112
6113 if (kernel_accel_chgd == 1)
6114 {
6115 if (kernel_accel < 1)
6116 {
6117 log_error ("ERROR: Invalid kernel-accel specified");
6118
6119 return (-1);
6120 }
6121
6122 if (kernel_accel > 1024)
6123 {
6124 log_error ("ERROR: Invalid kernel-accel specified");
6125
6126 return (-1);
6127 }
6128 }
6129
6130 if (kernel_loops_chgd == 1)
6131 {
6132 if (kernel_loops < 1)
6133 {
6134 log_error ("ERROR: Invalid kernel-loops specified");
6135
6136 return (-1);
6137 }
6138
6139 if (kernel_loops > 1024)
6140 {
6141 log_error ("ERROR: Invalid kernel-loops specified");
6142
6143 return (-1);
6144 }
6145 }
6146
6147 if ((workload_profile < 1) || (workload_profile > 3))
6148 {
6149 log_error ("ERROR: workload-profile %i not available", workload_profile);
6150
6151 return (-1);
6152 }
6153
6154 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6155 {
6156 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6157
6158 return (-1);
6159 }
6160
6161 if (show == 1 || left == 1)
6162 {
6163 attack_mode = ATTACK_MODE_NONE;
6164
6165 if (remove == 1)
6166 {
6167 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6168
6169 return (-1);
6170 }
6171
6172 if (potfile_disable == 1)
6173 {
6174 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6175
6176 return (-1);
6177 }
6178 }
6179
6180 uint attack_kern = ATTACK_KERN_NONE;
6181
6182 switch (attack_mode)
6183 {
6184 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6185 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6186 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6187 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6188 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6189 }
6190
6191 if (benchmark == 0)
6192 {
6193 if (keyspace == 1)
6194 {
6195 int num_additional_params = 1;
6196
6197 if (attack_kern == ATTACK_KERN_COMBI)
6198 {
6199 num_additional_params = 2;
6200 }
6201
6202 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6203
6204 if (keyspace_wordlist_specified == 0) optind--;
6205 }
6206
6207 if (attack_kern == ATTACK_KERN_NONE)
6208 {
6209 if ((optind + 1) != myargc)
6210 {
6211 usage_mini_print (myargv[0]);
6212
6213 return (-1);
6214 }
6215 }
6216 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6217 {
6218 if ((optind + 1) > myargc)
6219 {
6220 usage_mini_print (myargv[0]);
6221
6222 return (-1);
6223 }
6224 }
6225 else if (attack_kern == ATTACK_KERN_COMBI)
6226 {
6227 if ((optind + 3) != myargc)
6228 {
6229 usage_mini_print (myargv[0]);
6230
6231 return (-1);
6232 }
6233 }
6234 else if (attack_kern == ATTACK_KERN_BF)
6235 {
6236 if ((optind + 1) > myargc)
6237 {
6238 usage_mini_print (myargv[0]);
6239
6240 return (-1);
6241 }
6242 }
6243 else
6244 {
6245 usage_mini_print (myargv[0]);
6246
6247 return (-1);
6248 }
6249 }
6250 else
6251 {
6252 if (myargv[optind] != 0)
6253 {
6254 log_error ("ERROR: Invalid argument for benchmark mode specified");
6255
6256 return (-1);
6257 }
6258
6259 if (attack_mode_chgd == 1)
6260 {
6261 if (attack_mode != ATTACK_MODE_BF)
6262 {
6263 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6264
6265 return (-1);
6266 }
6267 }
6268 }
6269
6270 if (skip != 0 && limit != 0)
6271 {
6272 limit += skip;
6273 }
6274
6275 if (keyspace == 1)
6276 {
6277 if (show == 1)
6278 {
6279 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6280
6281 return (-1);
6282 }
6283 else if (left == 1)
6284 {
6285 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6286
6287 return (-1);
6288 }
6289
6290 potfile_disable = 1;
6291
6292 restore_disable = 1;
6293
6294 restore = 0;
6295
6296 weak_hash_threshold = 0;
6297
6298 quiet = 1;
6299 }
6300
6301 if (remove_timer_chgd == 1)
6302 {
6303 if (remove == 0)
6304 {
6305 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6306
6307 return (-1);
6308 }
6309
6310 if (remove_timer < 1)
6311 {
6312 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6313
6314 return (-1);
6315 }
6316 }
6317
6318 if (loopback == 1)
6319 {
6320 if (attack_mode == ATTACK_MODE_BF)
6321 {
6322 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
6323
6324 return (-1);
6325 }
6326 else if (attack_mode == ATTACK_MODE_STRAIGHT)
6327 {
6328 if ((rp_files_cnt == 0) && (rp_gen == 0))
6329 {
6330 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6331
6332 return (-1);
6333 }
6334 }
6335 }
6336
6337 if (debug_mode > 0)
6338 {
6339 if (attack_mode != ATTACK_MODE_STRAIGHT)
6340 {
6341 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6342
6343 return (-1);
6344 }
6345
6346 if ((rp_files_cnt == 0) && (rp_gen == 0))
6347 {
6348 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6349
6350 return (-1);
6351 }
6352 }
6353
6354 if (debug_mode > 4)
6355 {
6356 log_error ("ERROR: Invalid debug-mode specified");
6357
6358 return (-1);
6359 }
6360
6361 if (debug_file != NULL)
6362 {
6363 if (debug_mode < 1)
6364 {
6365 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6366
6367 return (-1);
6368 }
6369 }
6370
6371 if (induction_dir != NULL)
6372 {
6373 if (attack_mode == ATTACK_MODE_BF)
6374 {
6375 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6376
6377 return (-1);
6378 }
6379 }
6380
6381 if (attack_mode != ATTACK_MODE_STRAIGHT)
6382 {
6383 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6384 {
6385 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6386
6387 return (-1);
6388 }
6389
6390 weak_hash_threshold = 0;
6391 }
6392
6393 /**
6394 * induction directory
6395 */
6396
6397 char *induction_directory = NULL;
6398
6399 if (attack_mode != ATTACK_MODE_BF)
6400 {
6401 if (induction_dir == NULL)
6402 {
6403 induction_directory = (char *) mymalloc (session_size);
6404
6405 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6406
6407 // create induction folder if it does not already exist
6408
6409 if (keyspace == 0)
6410 {
6411 if (rmdir (induction_directory) == -1)
6412 {
6413 if (errno == ENOENT)
6414 {
6415 // good, we can ignore
6416 }
6417 else if (errno == ENOTEMPTY)
6418 {
6419 char *induction_directory_mv = (char *) mymalloc (session_size);
6420
6421 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6422
6423 if (rename (induction_directory, induction_directory_mv) != 0)
6424 {
6425 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6426
6427 return (-1);
6428 }
6429 }
6430 else
6431 {
6432 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6433
6434 return (-1);
6435 }
6436 }
6437
6438 if (mkdir (induction_directory, 0700) == -1)
6439 {
6440 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6441
6442 return (-1);
6443 }
6444 }
6445 }
6446 else
6447 {
6448 induction_directory = induction_dir;
6449 }
6450 }
6451
6452 data.induction_directory = induction_directory;
6453
6454 /**
6455 * loopback
6456 */
6457
6458 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6459
6460 char *loopback_file = (char *) mymalloc (loopback_size);
6461
6462 /**
6463 * tuning db
6464 */
6465
6466 char tuning_db_file[256] = { 0 };
6467
6468 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6469
6470 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6471
6472 /**
6473 * outfile-check directory
6474 */
6475
6476 char *outfile_check_directory = NULL;
6477
6478 if (outfile_check_dir == NULL)
6479 {
6480 outfile_check_directory = (char *) mymalloc (session_size);
6481
6482 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6483 }
6484 else
6485 {
6486 outfile_check_directory = outfile_check_dir;
6487 }
6488
6489 data.outfile_check_directory = outfile_check_directory;
6490
6491 if (keyspace == 0)
6492 {
6493 struct stat outfile_check_stat;
6494
6495 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6496 {
6497 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6498
6499 if (is_dir == 0)
6500 {
6501 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6502
6503 return (-1);
6504 }
6505 }
6506 else if (outfile_check_dir == NULL)
6507 {
6508 if (mkdir (outfile_check_directory, 0700) == -1)
6509 {
6510 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6511
6512 return (-1);
6513 }
6514 }
6515 }
6516
6517 /**
6518 * special other stuff
6519 */
6520
6521 if (hash_mode == 9710)
6522 {
6523 outfile_format = 5;
6524 outfile_format_chgd = 1;
6525 }
6526
6527 if (hash_mode == 9810)
6528 {
6529 outfile_format = 5;
6530 outfile_format_chgd = 1;
6531 }
6532
6533 if (hash_mode == 10410)
6534 {
6535 outfile_format = 5;
6536 outfile_format_chgd = 1;
6537 }
6538
6539 /**
6540 * store stuff
6541 */
6542
6543 data.hash_mode = hash_mode;
6544 data.restore = restore;
6545 data.restore_timer = restore_timer;
6546 data.restore_disable = restore_disable;
6547 data.status = status;
6548 data.status_timer = status_timer;
6549 data.status_automat = status_automat;
6550 data.loopback = loopback;
6551 data.runtime = runtime;
6552 data.remove = remove;
6553 data.remove_timer = remove_timer;
6554 data.debug_mode = debug_mode;
6555 data.debug_file = debug_file;
6556 data.username = username;
6557 data.quiet = quiet;
6558 data.outfile = outfile;
6559 data.outfile_format = outfile_format;
6560 data.outfile_autohex = outfile_autohex;
6561 data.hex_charset = hex_charset;
6562 data.hex_salt = hex_salt;
6563 data.hex_wordlist = hex_wordlist;
6564 data.separator = separator;
6565 data.rp_files = rp_files;
6566 data.rp_files_cnt = rp_files_cnt;
6567 data.rp_gen = rp_gen;
6568 data.rp_gen_seed = rp_gen_seed;
6569 data.force = force;
6570 data.benchmark = benchmark;
6571 data.benchmark_repeats = benchmark_repeats;
6572 data.skip = skip;
6573 data.limit = limit;
6574 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6575 data.powertune_enable = powertune_enable;
6576 #endif
6577 data.logfile_disable = logfile_disable;
6578 data.truecrypt_keyfiles = truecrypt_keyfiles;
6579 data.scrypt_tmto = scrypt_tmto;
6580 data.workload_profile = workload_profile;
6581
6582 /**
6583 * cpu affinity
6584 */
6585
6586 if (cpu_affinity)
6587 {
6588 set_cpu_affinity (cpu_affinity);
6589 }
6590
6591 if (rp_gen_seed_chgd == 0)
6592 {
6593 srand (proc_start);
6594 }
6595 else
6596 {
6597 srand (rp_gen_seed);
6598 }
6599
6600 /**
6601 * logfile init
6602 */
6603
6604 if (logfile_disable == 0)
6605 {
6606 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6607
6608 char *logfile = (char *) mymalloc (logfile_size);
6609
6610 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6611
6612 data.logfile = logfile;
6613
6614 char *topid = logfile_generate_topid ();
6615
6616 data.topid = topid;
6617 }
6618
6619 // logfile_append() checks for logfile_disable internally to make it easier from here
6620
6621 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6622 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6623 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6624 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6625 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6626 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6627 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6628 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6629 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6630 #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));
6631
6632 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6633 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6634 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6635 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6636 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6637 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6638 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6639 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6640
6641 logfile_top_msg ("START");
6642
6643 logfile_top_uint (attack_mode);
6644 logfile_top_uint (attack_kern);
6645 logfile_top_uint (benchmark);
6646 logfile_top_uint (benchmark_repeats);
6647 logfile_top_uint (bitmap_min);
6648 logfile_top_uint (bitmap_max);
6649 logfile_top_uint (debug_mode);
6650 logfile_top_uint (force);
6651 logfile_top_uint (kernel_accel);
6652 logfile_top_uint (kernel_loops);
6653 logfile_top_uint (gpu_temp_disable);
6654 #ifdef HAVE_HWMON
6655 logfile_top_uint (gpu_temp_abort);
6656 logfile_top_uint (gpu_temp_retain);
6657 #endif
6658 logfile_top_uint (hash_mode);
6659 logfile_top_uint (hex_charset);
6660 logfile_top_uint (hex_salt);
6661 logfile_top_uint (hex_wordlist);
6662 logfile_top_uint (increment);
6663 logfile_top_uint (increment_max);
6664 logfile_top_uint (increment_min);
6665 logfile_top_uint (keyspace);
6666 logfile_top_uint (left);
6667 logfile_top_uint (logfile_disable);
6668 logfile_top_uint (loopback);
6669 logfile_top_uint (markov_classic);
6670 logfile_top_uint (markov_disable);
6671 logfile_top_uint (markov_threshold);
6672 logfile_top_uint (outfile_autohex);
6673 logfile_top_uint (outfile_check_timer);
6674 logfile_top_uint (outfile_format);
6675 logfile_top_uint (potfile_disable);
6676 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6677 logfile_top_uint (powertune_enable);
6678 #endif
6679 logfile_top_uint (scrypt_tmto);
6680 logfile_top_uint (quiet);
6681 logfile_top_uint (remove);
6682 logfile_top_uint (remove_timer);
6683 logfile_top_uint (restore);
6684 logfile_top_uint (restore_disable);
6685 logfile_top_uint (restore_timer);
6686 logfile_top_uint (rp_gen);
6687 logfile_top_uint (rp_gen_func_max);
6688 logfile_top_uint (rp_gen_func_min);
6689 logfile_top_uint (rp_gen_seed);
6690 logfile_top_uint (runtime);
6691 logfile_top_uint (segment_size);
6692 logfile_top_uint (show);
6693 logfile_top_uint (status);
6694 logfile_top_uint (status_automat);
6695 logfile_top_uint (status_timer);
6696 logfile_top_uint (usage);
6697 logfile_top_uint (username);
6698 logfile_top_uint (version);
6699 logfile_top_uint (weak_hash_threshold);
6700 logfile_top_uint (workload_profile);
6701 logfile_top_uint64 (limit);
6702 logfile_top_uint64 (skip);
6703 logfile_top_char (separator);
6704 logfile_top_string (cpu_affinity);
6705 logfile_top_string (custom_charset_1);
6706 logfile_top_string (custom_charset_2);
6707 logfile_top_string (custom_charset_3);
6708 logfile_top_string (custom_charset_4);
6709 logfile_top_string (debug_file);
6710 logfile_top_string (opencl_devices);
6711 logfile_top_string (opencl_platforms);
6712 logfile_top_string (opencl_device_types);
6713 logfile_top_uint (opencl_vector_width);
6714 logfile_top_string (induction_dir);
6715 logfile_top_string (markov_hcstat);
6716 logfile_top_string (outfile);
6717 logfile_top_string (outfile_check_dir);
6718 logfile_top_string (rule_buf_l);
6719 logfile_top_string (rule_buf_r);
6720 logfile_top_string (session);
6721 logfile_top_string (truecrypt_keyfiles);
6722
6723 /**
6724 * Init OpenCL library loader
6725 */
6726
6727 if (keyspace == 0)
6728 {
6729 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6730
6731 ocl_init (ocl);
6732
6733 data.ocl = ocl;
6734 }
6735
6736 /**
6737 * OpenCL platform selection
6738 */
6739
6740 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6741
6742 /**
6743 * OpenCL device selection
6744 */
6745
6746 u32 devices_filter = setup_devices_filter (opencl_devices);
6747
6748 /**
6749 * OpenCL device type selection
6750 */
6751
6752 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6753
6754 /**
6755 * benchmark
6756 */
6757
6758 if (benchmark == 1)
6759 {
6760 /**
6761 * disable useless stuff for benchmark
6762 */
6763
6764 status_timer = 0;
6765 restore_timer = 0;
6766 restore_disable = 1;
6767 potfile_disable = 1;
6768 weak_hash_threshold = 0;
6769 gpu_temp_disable = 1;
6770
6771 data.status_timer = status_timer;
6772 data.restore_timer = restore_timer;
6773 data.restore_disable = restore_disable;
6774
6775 /**
6776 * force attack mode to be bruteforce
6777 */
6778
6779 attack_mode = ATTACK_MODE_BF;
6780 attack_kern = ATTACK_KERN_BF;
6781
6782 if (workload_profile_chgd == 0)
6783 {
6784 workload_profile = 3;
6785
6786 data.workload_profile = workload_profile;
6787 }
6788 }
6789
6790 /**
6791 * config
6792 */
6793
6794 uint hash_type = 0;
6795 uint salt_type = 0;
6796 uint attack_exec = 0;
6797 uint opts_type = 0;
6798 uint kern_type = 0;
6799 uint dgst_size = 0;
6800 uint esalt_size = 0;
6801 uint opti_type = 0;
6802 uint dgst_pos0 = -1;
6803 uint dgst_pos1 = -1;
6804 uint dgst_pos2 = -1;
6805 uint dgst_pos3 = -1;
6806
6807 int (*parse_func) (char *, uint, hash_t *);
6808 int (*sort_by_digest) (const void *, const void *);
6809
6810 uint algorithm_pos = 0;
6811 uint algorithm_max = 1;
6812
6813 uint *algorithms = default_benchmark_algorithms;
6814
6815 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6816
6817 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6818 {
6819 /*
6820 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6821 * the following algos are skipped entirely
6822 */
6823
6824 if (algorithm_pos > 0)
6825 {
6826 local_free (rd);
6827
6828 rd = init_restore (argc, argv);
6829
6830 data.rd = rd;
6831 }
6832
6833 /**
6834 * update hash_mode in case of multihash benchmark
6835 */
6836
6837 if (benchmark == 1)
6838 {
6839 if (hash_mode_chgd == 0)
6840 {
6841 hash_mode = algorithms[algorithm_pos];
6842
6843 data.hash_mode = hash_mode;
6844 }
6845
6846 quiet = 1;
6847
6848 data.quiet = quiet;
6849 }
6850
6851 switch (hash_mode)
6852 {
6853 case 0: hash_type = HASH_TYPE_MD5;
6854 salt_type = SALT_TYPE_NONE;
6855 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6856 opts_type = OPTS_TYPE_PT_GENERATE_LE
6857 | OPTS_TYPE_PT_ADD80
6858 | OPTS_TYPE_PT_ADDBITS14;
6859 kern_type = KERN_TYPE_MD5;
6860 dgst_size = DGST_SIZE_4_4;
6861 parse_func = md5_parse_hash;
6862 sort_by_digest = sort_by_digest_4_4;
6863 opti_type = OPTI_TYPE_ZERO_BYTE
6864 | OPTI_TYPE_PRECOMPUTE_INIT
6865 | OPTI_TYPE_PRECOMPUTE_MERKLE
6866 | OPTI_TYPE_MEET_IN_MIDDLE
6867 | OPTI_TYPE_EARLY_SKIP
6868 | OPTI_TYPE_NOT_ITERATED
6869 | OPTI_TYPE_NOT_SALTED
6870 | OPTI_TYPE_RAW_HASH;
6871 dgst_pos0 = 0;
6872 dgst_pos1 = 3;
6873 dgst_pos2 = 2;
6874 dgst_pos3 = 1;
6875 break;
6876
6877 case 10: hash_type = HASH_TYPE_MD5;
6878 salt_type = SALT_TYPE_INTERN;
6879 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6880 opts_type = OPTS_TYPE_PT_GENERATE_LE
6881 | OPTS_TYPE_ST_ADD80
6882 | OPTS_TYPE_ST_ADDBITS14;
6883 kern_type = KERN_TYPE_MD5_PWSLT;
6884 dgst_size = DGST_SIZE_4_4;
6885 parse_func = md5s_parse_hash;
6886 sort_by_digest = sort_by_digest_4_4;
6887 opti_type = OPTI_TYPE_ZERO_BYTE
6888 | OPTI_TYPE_PRECOMPUTE_INIT
6889 | OPTI_TYPE_PRECOMPUTE_MERKLE
6890 | OPTI_TYPE_MEET_IN_MIDDLE
6891 | OPTI_TYPE_EARLY_SKIP
6892 | OPTI_TYPE_NOT_ITERATED
6893 | OPTI_TYPE_APPENDED_SALT
6894 | OPTI_TYPE_RAW_HASH;
6895 dgst_pos0 = 0;
6896 dgst_pos1 = 3;
6897 dgst_pos2 = 2;
6898 dgst_pos3 = 1;
6899 break;
6900
6901 case 11: hash_type = HASH_TYPE_MD5;
6902 salt_type = SALT_TYPE_INTERN;
6903 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6904 opts_type = OPTS_TYPE_PT_GENERATE_LE
6905 | OPTS_TYPE_ST_ADD80
6906 | OPTS_TYPE_ST_ADDBITS14;
6907 kern_type = KERN_TYPE_MD5_PWSLT;
6908 dgst_size = DGST_SIZE_4_4;
6909 parse_func = joomla_parse_hash;
6910 sort_by_digest = sort_by_digest_4_4;
6911 opti_type = OPTI_TYPE_ZERO_BYTE
6912 | OPTI_TYPE_PRECOMPUTE_INIT
6913 | OPTI_TYPE_PRECOMPUTE_MERKLE
6914 | OPTI_TYPE_MEET_IN_MIDDLE
6915 | OPTI_TYPE_EARLY_SKIP
6916 | OPTI_TYPE_NOT_ITERATED
6917 | OPTI_TYPE_APPENDED_SALT
6918 | OPTI_TYPE_RAW_HASH;
6919 dgst_pos0 = 0;
6920 dgst_pos1 = 3;
6921 dgst_pos2 = 2;
6922 dgst_pos3 = 1;
6923 break;
6924
6925 case 12: hash_type = HASH_TYPE_MD5;
6926 salt_type = SALT_TYPE_INTERN;
6927 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6928 opts_type = OPTS_TYPE_PT_GENERATE_LE
6929 | OPTS_TYPE_ST_ADD80
6930 | OPTS_TYPE_ST_ADDBITS14;
6931 kern_type = KERN_TYPE_MD5_PWSLT;
6932 dgst_size = DGST_SIZE_4_4;
6933 parse_func = postgresql_parse_hash;
6934 sort_by_digest = sort_by_digest_4_4;
6935 opti_type = OPTI_TYPE_ZERO_BYTE
6936 | OPTI_TYPE_PRECOMPUTE_INIT
6937 | OPTI_TYPE_PRECOMPUTE_MERKLE
6938 | OPTI_TYPE_MEET_IN_MIDDLE
6939 | OPTI_TYPE_EARLY_SKIP
6940 | OPTI_TYPE_NOT_ITERATED
6941 | OPTI_TYPE_APPENDED_SALT
6942 | OPTI_TYPE_RAW_HASH;
6943 dgst_pos0 = 0;
6944 dgst_pos1 = 3;
6945 dgst_pos2 = 2;
6946 dgst_pos3 = 1;
6947 break;
6948
6949 case 20: hash_type = HASH_TYPE_MD5;
6950 salt_type = SALT_TYPE_INTERN;
6951 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6952 opts_type = OPTS_TYPE_PT_GENERATE_LE
6953 | OPTS_TYPE_PT_ADD80
6954 | OPTS_TYPE_PT_ADDBITS14;
6955 kern_type = KERN_TYPE_MD5_SLTPW;
6956 dgst_size = DGST_SIZE_4_4;
6957 parse_func = md5s_parse_hash;
6958 sort_by_digest = sort_by_digest_4_4;
6959 opti_type = OPTI_TYPE_ZERO_BYTE
6960 | OPTI_TYPE_PRECOMPUTE_INIT
6961 | OPTI_TYPE_PRECOMPUTE_MERKLE
6962 | OPTI_TYPE_EARLY_SKIP
6963 | OPTI_TYPE_NOT_ITERATED
6964 | OPTI_TYPE_PREPENDED_SALT
6965 | OPTI_TYPE_RAW_HASH;
6966 dgst_pos0 = 0;
6967 dgst_pos1 = 3;
6968 dgst_pos2 = 2;
6969 dgst_pos3 = 1;
6970 break;
6971
6972 case 21: hash_type = HASH_TYPE_MD5;
6973 salt_type = SALT_TYPE_INTERN;
6974 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6975 opts_type = OPTS_TYPE_PT_GENERATE_LE
6976 | OPTS_TYPE_PT_ADD80
6977 | OPTS_TYPE_PT_ADDBITS14;
6978 kern_type = KERN_TYPE_MD5_SLTPW;
6979 dgst_size = DGST_SIZE_4_4;
6980 parse_func = osc_parse_hash;
6981 sort_by_digest = sort_by_digest_4_4;
6982 opti_type = OPTI_TYPE_ZERO_BYTE
6983 | OPTI_TYPE_PRECOMPUTE_INIT
6984 | OPTI_TYPE_PRECOMPUTE_MERKLE
6985 | OPTI_TYPE_EARLY_SKIP
6986 | OPTI_TYPE_NOT_ITERATED
6987 | OPTI_TYPE_PREPENDED_SALT
6988 | OPTI_TYPE_RAW_HASH;
6989 dgst_pos0 = 0;
6990 dgst_pos1 = 3;
6991 dgst_pos2 = 2;
6992 dgst_pos3 = 1;
6993 break;
6994
6995 case 22: hash_type = HASH_TYPE_MD5;
6996 salt_type = SALT_TYPE_EMBEDDED;
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_SLTPW;
7002 dgst_size = DGST_SIZE_4_4;
7003 parse_func = netscreen_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_EARLY_SKIP
7009 | OPTI_TYPE_NOT_ITERATED
7010 | OPTI_TYPE_PREPENDED_SALT
7011 | OPTI_TYPE_RAW_HASH;
7012 dgst_pos0 = 0;
7013 dgst_pos1 = 3;
7014 dgst_pos2 = 2;
7015 dgst_pos3 = 1;
7016 break;
7017
7018 case 23: hash_type = HASH_TYPE_MD5;
7019 salt_type = SALT_TYPE_EMBEDDED;
7020 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7021 opts_type = OPTS_TYPE_PT_GENERATE_LE
7022 | OPTS_TYPE_PT_ADD80
7023 | OPTS_TYPE_PT_ADDBITS14;
7024 kern_type = KERN_TYPE_MD5_SLTPW;
7025 dgst_size = DGST_SIZE_4_4;
7026 parse_func = skype_parse_hash;
7027 sort_by_digest = sort_by_digest_4_4;
7028 opti_type = OPTI_TYPE_ZERO_BYTE
7029 | OPTI_TYPE_PRECOMPUTE_INIT
7030 | OPTI_TYPE_PRECOMPUTE_MERKLE
7031 | OPTI_TYPE_EARLY_SKIP
7032 | OPTI_TYPE_NOT_ITERATED
7033 | OPTI_TYPE_PREPENDED_SALT
7034 | OPTI_TYPE_RAW_HASH;
7035 dgst_pos0 = 0;
7036 dgst_pos1 = 3;
7037 dgst_pos2 = 2;
7038 dgst_pos3 = 1;
7039 break;
7040
7041 case 30: hash_type = HASH_TYPE_MD5;
7042 salt_type = SALT_TYPE_INTERN;
7043 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7044 opts_type = OPTS_TYPE_PT_GENERATE_LE
7045 | OPTS_TYPE_PT_UNICODE
7046 | OPTS_TYPE_ST_ADD80
7047 | OPTS_TYPE_ST_ADDBITS14;
7048 kern_type = KERN_TYPE_MD5_PWUSLT;
7049 dgst_size = DGST_SIZE_4_4;
7050 parse_func = md5s_parse_hash;
7051 sort_by_digest = sort_by_digest_4_4;
7052 opti_type = OPTI_TYPE_ZERO_BYTE
7053 | OPTI_TYPE_PRECOMPUTE_INIT
7054 | OPTI_TYPE_PRECOMPUTE_MERKLE
7055 | OPTI_TYPE_MEET_IN_MIDDLE
7056 | OPTI_TYPE_EARLY_SKIP
7057 | OPTI_TYPE_NOT_ITERATED
7058 | OPTI_TYPE_APPENDED_SALT
7059 | OPTI_TYPE_RAW_HASH;
7060 dgst_pos0 = 0;
7061 dgst_pos1 = 3;
7062 dgst_pos2 = 2;
7063 dgst_pos3 = 1;
7064 break;
7065
7066 case 40: hash_type = HASH_TYPE_MD5;
7067 salt_type = SALT_TYPE_INTERN;
7068 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7069 opts_type = OPTS_TYPE_PT_GENERATE_LE
7070 | OPTS_TYPE_PT_ADD80
7071 | OPTS_TYPE_PT_ADDBITS14
7072 | OPTS_TYPE_PT_UNICODE;
7073 kern_type = KERN_TYPE_MD5_SLTPWU;
7074 dgst_size = DGST_SIZE_4_4;
7075 parse_func = md5s_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_EARLY_SKIP
7081 | OPTI_TYPE_NOT_ITERATED
7082 | OPTI_TYPE_PREPENDED_SALT
7083 | OPTI_TYPE_RAW_HASH;
7084 dgst_pos0 = 0;
7085 dgst_pos1 = 3;
7086 dgst_pos2 = 2;
7087 dgst_pos3 = 1;
7088 break;
7089
7090 case 50: hash_type = HASH_TYPE_MD5;
7091 salt_type = SALT_TYPE_INTERN;
7092 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7093 opts_type = OPTS_TYPE_PT_GENERATE_LE
7094 | OPTS_TYPE_ST_ADD80
7095 | OPTS_TYPE_ST_ADDBITS14;
7096 kern_type = KERN_TYPE_HMACMD5_PW;
7097 dgst_size = DGST_SIZE_4_4;
7098 parse_func = hmacmd5_parse_hash;
7099 sort_by_digest = sort_by_digest_4_4;
7100 opti_type = OPTI_TYPE_ZERO_BYTE
7101 | OPTI_TYPE_NOT_ITERATED;
7102 dgst_pos0 = 0;
7103 dgst_pos1 = 3;
7104 dgst_pos2 = 2;
7105 dgst_pos3 = 1;
7106 break;
7107
7108 case 60: hash_type = HASH_TYPE_MD5;
7109 salt_type = SALT_TYPE_INTERN;
7110 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7111 opts_type = OPTS_TYPE_PT_GENERATE_LE
7112 | OPTS_TYPE_PT_ADD80
7113 | OPTS_TYPE_PT_ADDBITS14;
7114 kern_type = KERN_TYPE_HMACMD5_SLT;
7115 dgst_size = DGST_SIZE_4_4;
7116 parse_func = hmacmd5_parse_hash;
7117 sort_by_digest = sort_by_digest_4_4;
7118 opti_type = OPTI_TYPE_ZERO_BYTE
7119 | OPTI_TYPE_NOT_ITERATED;
7120 dgst_pos0 = 0;
7121 dgst_pos1 = 3;
7122 dgst_pos2 = 2;
7123 dgst_pos3 = 1;
7124 break;
7125
7126 case 100: hash_type = HASH_TYPE_SHA1;
7127 salt_type = SALT_TYPE_NONE;
7128 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7129 opts_type = OPTS_TYPE_PT_GENERATE_BE
7130 | OPTS_TYPE_PT_ADD80
7131 | OPTS_TYPE_PT_ADDBITS15;
7132 kern_type = KERN_TYPE_SHA1;
7133 dgst_size = DGST_SIZE_4_5;
7134 parse_func = sha1_parse_hash;
7135 sort_by_digest = sort_by_digest_4_5;
7136 opti_type = OPTI_TYPE_ZERO_BYTE
7137 | OPTI_TYPE_PRECOMPUTE_INIT
7138 | OPTI_TYPE_PRECOMPUTE_MERKLE
7139 | OPTI_TYPE_EARLY_SKIP
7140 | OPTI_TYPE_NOT_ITERATED
7141 | OPTI_TYPE_NOT_SALTED
7142 | OPTI_TYPE_RAW_HASH;
7143 dgst_pos0 = 3;
7144 dgst_pos1 = 4;
7145 dgst_pos2 = 2;
7146 dgst_pos3 = 1;
7147 break;
7148
7149 case 101: hash_type = HASH_TYPE_SHA1;
7150 salt_type = SALT_TYPE_NONE;
7151 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7152 opts_type = OPTS_TYPE_PT_GENERATE_BE
7153 | OPTS_TYPE_PT_ADD80
7154 | OPTS_TYPE_PT_ADDBITS15;
7155 kern_type = KERN_TYPE_SHA1;
7156 dgst_size = DGST_SIZE_4_5;
7157 parse_func = sha1b64_parse_hash;
7158 sort_by_digest = sort_by_digest_4_5;
7159 opti_type = OPTI_TYPE_ZERO_BYTE
7160 | OPTI_TYPE_PRECOMPUTE_INIT
7161 | OPTI_TYPE_PRECOMPUTE_MERKLE
7162 | OPTI_TYPE_EARLY_SKIP
7163 | OPTI_TYPE_NOT_ITERATED
7164 | OPTI_TYPE_NOT_SALTED
7165 | OPTI_TYPE_RAW_HASH;
7166 dgst_pos0 = 3;
7167 dgst_pos1 = 4;
7168 dgst_pos2 = 2;
7169 dgst_pos3 = 1;
7170 break;
7171
7172 case 110: hash_type = HASH_TYPE_SHA1;
7173 salt_type = SALT_TYPE_INTERN;
7174 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7175 opts_type = OPTS_TYPE_PT_GENERATE_BE
7176 | OPTS_TYPE_ST_ADD80
7177 | OPTS_TYPE_ST_ADDBITS15;
7178 kern_type = KERN_TYPE_SHA1_PWSLT;
7179 dgst_size = DGST_SIZE_4_5;
7180 parse_func = sha1s_parse_hash;
7181 sort_by_digest = sort_by_digest_4_5;
7182 opti_type = OPTI_TYPE_ZERO_BYTE
7183 | OPTI_TYPE_PRECOMPUTE_INIT
7184 | OPTI_TYPE_PRECOMPUTE_MERKLE
7185 | OPTI_TYPE_EARLY_SKIP
7186 | OPTI_TYPE_NOT_ITERATED
7187 | OPTI_TYPE_APPENDED_SALT
7188 | OPTI_TYPE_RAW_HASH;
7189 dgst_pos0 = 3;
7190 dgst_pos1 = 4;
7191 dgst_pos2 = 2;
7192 dgst_pos3 = 1;
7193 break;
7194
7195 case 111: hash_type = HASH_TYPE_SHA1;
7196 salt_type = SALT_TYPE_EMBEDDED;
7197 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7198 opts_type = OPTS_TYPE_PT_GENERATE_BE
7199 | OPTS_TYPE_ST_ADD80
7200 | OPTS_TYPE_ST_ADDBITS15;
7201 kern_type = KERN_TYPE_SHA1_PWSLT;
7202 dgst_size = DGST_SIZE_4_5;
7203 parse_func = sha1b64s_parse_hash;
7204 sort_by_digest = sort_by_digest_4_5;
7205 opti_type = OPTI_TYPE_ZERO_BYTE
7206 | OPTI_TYPE_PRECOMPUTE_INIT
7207 | OPTI_TYPE_PRECOMPUTE_MERKLE
7208 | OPTI_TYPE_EARLY_SKIP
7209 | OPTI_TYPE_NOT_ITERATED
7210 | OPTI_TYPE_APPENDED_SALT
7211 | OPTI_TYPE_RAW_HASH;
7212 dgst_pos0 = 3;
7213 dgst_pos1 = 4;
7214 dgst_pos2 = 2;
7215 dgst_pos3 = 1;
7216 break;
7217
7218 case 112: hash_type = HASH_TYPE_SHA1;
7219 salt_type = SALT_TYPE_INTERN;
7220 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7221 opts_type = OPTS_TYPE_PT_GENERATE_BE
7222 | OPTS_TYPE_ST_ADD80
7223 | OPTS_TYPE_ST_ADDBITS15
7224 | OPTS_TYPE_ST_HEX;
7225 kern_type = KERN_TYPE_SHA1_PWSLT;
7226 dgst_size = DGST_SIZE_4_5;
7227 parse_func = oracles_parse_hash;
7228 sort_by_digest = sort_by_digest_4_5;
7229 opti_type = OPTI_TYPE_ZERO_BYTE
7230 | OPTI_TYPE_PRECOMPUTE_INIT
7231 | OPTI_TYPE_PRECOMPUTE_MERKLE
7232 | OPTI_TYPE_EARLY_SKIP
7233 | OPTI_TYPE_NOT_ITERATED
7234 | OPTI_TYPE_APPENDED_SALT
7235 | OPTI_TYPE_RAW_HASH;
7236 dgst_pos0 = 3;
7237 dgst_pos1 = 4;
7238 dgst_pos2 = 2;
7239 dgst_pos3 = 1;
7240 break;
7241
7242 case 120: hash_type = HASH_TYPE_SHA1;
7243 salt_type = SALT_TYPE_INTERN;
7244 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7245 opts_type = OPTS_TYPE_PT_GENERATE_BE
7246 | OPTS_TYPE_PT_ADD80
7247 | OPTS_TYPE_PT_ADDBITS15;
7248 kern_type = KERN_TYPE_SHA1_SLTPW;
7249 dgst_size = DGST_SIZE_4_5;
7250 parse_func = sha1s_parse_hash;
7251 sort_by_digest = sort_by_digest_4_5;
7252 opti_type = OPTI_TYPE_ZERO_BYTE
7253 | OPTI_TYPE_PRECOMPUTE_INIT
7254 | OPTI_TYPE_PRECOMPUTE_MERKLE
7255 | OPTI_TYPE_EARLY_SKIP
7256 | OPTI_TYPE_NOT_ITERATED
7257 | OPTI_TYPE_PREPENDED_SALT
7258 | OPTI_TYPE_RAW_HASH;
7259 dgst_pos0 = 3;
7260 dgst_pos1 = 4;
7261 dgst_pos2 = 2;
7262 dgst_pos3 = 1;
7263 break;
7264
7265 case 121: hash_type = HASH_TYPE_SHA1;
7266 salt_type = SALT_TYPE_INTERN;
7267 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7268 opts_type = OPTS_TYPE_PT_GENERATE_BE
7269 | OPTS_TYPE_PT_ADD80
7270 | OPTS_TYPE_PT_ADDBITS15
7271 | OPTS_TYPE_ST_LOWER;
7272 kern_type = KERN_TYPE_SHA1_SLTPW;
7273 dgst_size = DGST_SIZE_4_5;
7274 parse_func = smf_parse_hash;
7275 sort_by_digest = sort_by_digest_4_5;
7276 opti_type = OPTI_TYPE_ZERO_BYTE
7277 | OPTI_TYPE_PRECOMPUTE_INIT
7278 | OPTI_TYPE_PRECOMPUTE_MERKLE
7279 | OPTI_TYPE_EARLY_SKIP
7280 | OPTI_TYPE_NOT_ITERATED
7281 | OPTI_TYPE_PREPENDED_SALT
7282 | OPTI_TYPE_RAW_HASH;
7283 dgst_pos0 = 3;
7284 dgst_pos1 = 4;
7285 dgst_pos2 = 2;
7286 dgst_pos3 = 1;
7287 break;
7288
7289 case 122: hash_type = HASH_TYPE_SHA1;
7290 salt_type = SALT_TYPE_EMBEDDED;
7291 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7292 opts_type = OPTS_TYPE_PT_GENERATE_BE
7293 | OPTS_TYPE_PT_ADD80
7294 | OPTS_TYPE_PT_ADDBITS15
7295 | OPTS_TYPE_ST_HEX;
7296 kern_type = KERN_TYPE_SHA1_SLTPW;
7297 dgst_size = DGST_SIZE_4_5;
7298 parse_func = osx1_parse_hash;
7299 sort_by_digest = sort_by_digest_4_5;
7300 opti_type = OPTI_TYPE_ZERO_BYTE
7301 | OPTI_TYPE_PRECOMPUTE_INIT
7302 | OPTI_TYPE_PRECOMPUTE_MERKLE
7303 | OPTI_TYPE_EARLY_SKIP
7304 | OPTI_TYPE_NOT_ITERATED
7305 | OPTI_TYPE_PREPENDED_SALT
7306 | OPTI_TYPE_RAW_HASH;
7307 dgst_pos0 = 3;
7308 dgst_pos1 = 4;
7309 dgst_pos2 = 2;
7310 dgst_pos3 = 1;
7311 break;
7312
7313 case 124: hash_type = HASH_TYPE_SHA1;
7314 salt_type = SALT_TYPE_EMBEDDED;
7315 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7316 opts_type = OPTS_TYPE_PT_GENERATE_BE
7317 | OPTS_TYPE_PT_ADD80
7318 | OPTS_TYPE_PT_ADDBITS15;
7319 kern_type = KERN_TYPE_SHA1_SLTPW;
7320 dgst_size = DGST_SIZE_4_5;
7321 parse_func = djangosha1_parse_hash;
7322 sort_by_digest = sort_by_digest_4_5;
7323 opti_type = OPTI_TYPE_ZERO_BYTE
7324 | OPTI_TYPE_PRECOMPUTE_INIT
7325 | OPTI_TYPE_PRECOMPUTE_MERKLE
7326 | OPTI_TYPE_EARLY_SKIP
7327 | OPTI_TYPE_NOT_ITERATED
7328 | OPTI_TYPE_PREPENDED_SALT
7329 | OPTI_TYPE_RAW_HASH;
7330 dgst_pos0 = 3;
7331 dgst_pos1 = 4;
7332 dgst_pos2 = 2;
7333 dgst_pos3 = 1;
7334 break;
7335
7336 case 130: hash_type = HASH_TYPE_SHA1;
7337 salt_type = SALT_TYPE_INTERN;
7338 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7339 opts_type = OPTS_TYPE_PT_GENERATE_BE
7340 | OPTS_TYPE_PT_UNICODE
7341 | OPTS_TYPE_ST_ADD80
7342 | OPTS_TYPE_ST_ADDBITS15;
7343 kern_type = KERN_TYPE_SHA1_PWUSLT;
7344 dgst_size = DGST_SIZE_4_5;
7345 parse_func = sha1s_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 131: hash_type = HASH_TYPE_SHA1;
7361 salt_type = SALT_TYPE_EMBEDDED;
7362 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7363 opts_type = OPTS_TYPE_PT_GENERATE_BE
7364 | OPTS_TYPE_PT_UNICODE
7365 | OPTS_TYPE_PT_UPPER
7366 | OPTS_TYPE_ST_ADD80
7367 | OPTS_TYPE_ST_ADDBITS15
7368 | OPTS_TYPE_ST_HEX;
7369 kern_type = KERN_TYPE_SHA1_PWUSLT;
7370 dgst_size = DGST_SIZE_4_5;
7371 parse_func = mssql2000_parse_hash;
7372 sort_by_digest = sort_by_digest_4_5;
7373 opti_type = OPTI_TYPE_ZERO_BYTE
7374 | OPTI_TYPE_PRECOMPUTE_INIT
7375 | OPTI_TYPE_PRECOMPUTE_MERKLE
7376 | OPTI_TYPE_EARLY_SKIP
7377 | OPTI_TYPE_NOT_ITERATED
7378 | OPTI_TYPE_APPENDED_SALT
7379 | OPTI_TYPE_RAW_HASH;
7380 dgst_pos0 = 3;
7381 dgst_pos1 = 4;
7382 dgst_pos2 = 2;
7383 dgst_pos3 = 1;
7384 break;
7385
7386 case 132: hash_type = HASH_TYPE_SHA1;
7387 salt_type = SALT_TYPE_EMBEDDED;
7388 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7389 opts_type = OPTS_TYPE_PT_GENERATE_BE
7390 | OPTS_TYPE_PT_UNICODE
7391 | OPTS_TYPE_ST_ADD80
7392 | OPTS_TYPE_ST_ADDBITS15
7393 | OPTS_TYPE_ST_HEX;
7394 kern_type = KERN_TYPE_SHA1_PWUSLT;
7395 dgst_size = DGST_SIZE_4_5;
7396 parse_func = mssql2005_parse_hash;
7397 sort_by_digest = sort_by_digest_4_5;
7398 opti_type = OPTI_TYPE_ZERO_BYTE
7399 | OPTI_TYPE_PRECOMPUTE_INIT
7400 | OPTI_TYPE_PRECOMPUTE_MERKLE
7401 | OPTI_TYPE_EARLY_SKIP
7402 | OPTI_TYPE_NOT_ITERATED
7403 | OPTI_TYPE_APPENDED_SALT
7404 | OPTI_TYPE_RAW_HASH;
7405 dgst_pos0 = 3;
7406 dgst_pos1 = 4;
7407 dgst_pos2 = 2;
7408 dgst_pos3 = 1;
7409 break;
7410
7411 case 133: hash_type = HASH_TYPE_SHA1;
7412 salt_type = SALT_TYPE_EMBEDDED;
7413 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7414 opts_type = OPTS_TYPE_PT_GENERATE_BE
7415 | OPTS_TYPE_PT_UNICODE
7416 | OPTS_TYPE_ST_ADD80
7417 | OPTS_TYPE_ST_ADDBITS15;
7418 kern_type = KERN_TYPE_SHA1_PWUSLT;
7419 dgst_size = DGST_SIZE_4_5;
7420 parse_func = peoplesoft_parse_hash;
7421 sort_by_digest = sort_by_digest_4_5;
7422 opti_type = OPTI_TYPE_ZERO_BYTE
7423 | OPTI_TYPE_PRECOMPUTE_INIT
7424 | OPTI_TYPE_PRECOMPUTE_MERKLE
7425 | OPTI_TYPE_EARLY_SKIP
7426 | OPTI_TYPE_NOT_ITERATED
7427 | OPTI_TYPE_APPENDED_SALT
7428 | OPTI_TYPE_RAW_HASH;
7429 dgst_pos0 = 3;
7430 dgst_pos1 = 4;
7431 dgst_pos2 = 2;
7432 dgst_pos3 = 1;
7433 break;
7434
7435 case 140: hash_type = HASH_TYPE_SHA1;
7436 salt_type = SALT_TYPE_INTERN;
7437 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7438 opts_type = OPTS_TYPE_PT_GENERATE_BE
7439 | OPTS_TYPE_PT_ADD80
7440 | OPTS_TYPE_PT_ADDBITS15
7441 | OPTS_TYPE_PT_UNICODE;
7442 kern_type = KERN_TYPE_SHA1_SLTPWU;
7443 dgst_size = DGST_SIZE_4_5;
7444 parse_func = sha1s_parse_hash;
7445 sort_by_digest = sort_by_digest_4_5;
7446 opti_type = OPTI_TYPE_ZERO_BYTE
7447 | OPTI_TYPE_PRECOMPUTE_INIT
7448 | OPTI_TYPE_PRECOMPUTE_MERKLE
7449 | OPTI_TYPE_EARLY_SKIP
7450 | OPTI_TYPE_NOT_ITERATED
7451 | OPTI_TYPE_PREPENDED_SALT
7452 | OPTI_TYPE_RAW_HASH;
7453 dgst_pos0 = 3;
7454 dgst_pos1 = 4;
7455 dgst_pos2 = 2;
7456 dgst_pos3 = 1;
7457 break;
7458
7459 case 141: hash_type = HASH_TYPE_SHA1;
7460 salt_type = SALT_TYPE_EMBEDDED;
7461 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7462 opts_type = OPTS_TYPE_PT_GENERATE_BE
7463 | OPTS_TYPE_PT_ADD80
7464 | OPTS_TYPE_PT_ADDBITS15
7465 | OPTS_TYPE_PT_UNICODE
7466 | OPTS_TYPE_ST_BASE64;
7467 kern_type = KERN_TYPE_SHA1_SLTPWU;
7468 dgst_size = DGST_SIZE_4_5;
7469 parse_func = episerver_parse_hash;
7470 sort_by_digest = sort_by_digest_4_5;
7471 opti_type = OPTI_TYPE_ZERO_BYTE
7472 | OPTI_TYPE_PRECOMPUTE_INIT
7473 | OPTI_TYPE_PRECOMPUTE_MERKLE
7474 | OPTI_TYPE_EARLY_SKIP
7475 | OPTI_TYPE_NOT_ITERATED
7476 | OPTI_TYPE_PREPENDED_SALT
7477 | OPTI_TYPE_RAW_HASH;
7478 dgst_pos0 = 3;
7479 dgst_pos1 = 4;
7480 dgst_pos2 = 2;
7481 dgst_pos3 = 1;
7482 break;
7483
7484 case 150: hash_type = HASH_TYPE_SHA1;
7485 salt_type = SALT_TYPE_INTERN;
7486 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7487 opts_type = OPTS_TYPE_PT_GENERATE_BE
7488 | OPTS_TYPE_ST_ADD80
7489 | OPTS_TYPE_ST_ADDBITS15;
7490 kern_type = KERN_TYPE_HMACSHA1_PW;
7491 dgst_size = DGST_SIZE_4_5;
7492 parse_func = hmacsha1_parse_hash;
7493 sort_by_digest = sort_by_digest_4_5;
7494 opti_type = OPTI_TYPE_ZERO_BYTE
7495 | OPTI_TYPE_NOT_ITERATED;
7496 dgst_pos0 = 3;
7497 dgst_pos1 = 4;
7498 dgst_pos2 = 2;
7499 dgst_pos3 = 1;
7500 break;
7501
7502 case 160: hash_type = HASH_TYPE_SHA1;
7503 salt_type = SALT_TYPE_INTERN;
7504 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7505 opts_type = OPTS_TYPE_PT_GENERATE_BE
7506 | OPTS_TYPE_PT_ADD80
7507 | OPTS_TYPE_PT_ADDBITS15;
7508 kern_type = KERN_TYPE_HMACSHA1_SLT;
7509 dgst_size = DGST_SIZE_4_5;
7510 parse_func = hmacsha1_parse_hash;
7511 sort_by_digest = sort_by_digest_4_5;
7512 opti_type = OPTI_TYPE_ZERO_BYTE
7513 | OPTI_TYPE_NOT_ITERATED;
7514 dgst_pos0 = 3;
7515 dgst_pos1 = 4;
7516 dgst_pos2 = 2;
7517 dgst_pos3 = 1;
7518 break;
7519
7520 case 190: hash_type = HASH_TYPE_SHA1;
7521 salt_type = SALT_TYPE_NONE;
7522 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7523 opts_type = OPTS_TYPE_PT_GENERATE_BE
7524 | OPTS_TYPE_PT_ADD80
7525 | OPTS_TYPE_PT_ADDBITS15;
7526 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7527 dgst_size = DGST_SIZE_4_5;
7528 parse_func = sha1linkedin_parse_hash;
7529 sort_by_digest = sort_by_digest_4_5;
7530 opti_type = OPTI_TYPE_ZERO_BYTE
7531 | OPTI_TYPE_PRECOMPUTE_INIT
7532 | OPTI_TYPE_EARLY_SKIP
7533 | OPTI_TYPE_NOT_ITERATED
7534 | OPTI_TYPE_NOT_SALTED;
7535 dgst_pos0 = 0;
7536 dgst_pos1 = 4;
7537 dgst_pos2 = 3;
7538 dgst_pos3 = 2;
7539 break;
7540
7541 case 200: hash_type = HASH_TYPE_MYSQL;
7542 salt_type = SALT_TYPE_NONE;
7543 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7544 opts_type = 0;
7545 kern_type = KERN_TYPE_MYSQL;
7546 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7547 parse_func = mysql323_parse_hash;
7548 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7549 opti_type = OPTI_TYPE_ZERO_BYTE;
7550 dgst_pos0 = 0;
7551 dgst_pos1 = 1;
7552 dgst_pos2 = 2;
7553 dgst_pos3 = 3;
7554 break;
7555
7556 case 300: hash_type = HASH_TYPE_SHA1;
7557 salt_type = SALT_TYPE_NONE;
7558 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7559 opts_type = OPTS_TYPE_PT_GENERATE_BE
7560 | OPTS_TYPE_PT_ADD80
7561 | OPTS_TYPE_PT_ADDBITS15;
7562 kern_type = KERN_TYPE_MYSQL41;
7563 dgst_size = DGST_SIZE_4_5;
7564 parse_func = sha1_parse_hash;
7565 sort_by_digest = sort_by_digest_4_5;
7566 opti_type = OPTI_TYPE_ZERO_BYTE
7567 | OPTI_TYPE_PRECOMPUTE_INIT
7568 | OPTI_TYPE_PRECOMPUTE_MERKLE
7569 | OPTI_TYPE_EARLY_SKIP
7570 | OPTI_TYPE_NOT_ITERATED
7571 | OPTI_TYPE_NOT_SALTED;
7572 dgst_pos0 = 3;
7573 dgst_pos1 = 4;
7574 dgst_pos2 = 2;
7575 dgst_pos3 = 1;
7576 break;
7577
7578 case 400: hash_type = HASH_TYPE_MD5;
7579 salt_type = SALT_TYPE_EMBEDDED;
7580 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7581 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7582 kern_type = KERN_TYPE_PHPASS;
7583 dgst_size = DGST_SIZE_4_4;
7584 parse_func = phpass_parse_hash;
7585 sort_by_digest = sort_by_digest_4_4;
7586 opti_type = OPTI_TYPE_ZERO_BYTE;
7587 dgst_pos0 = 0;
7588 dgst_pos1 = 1;
7589 dgst_pos2 = 2;
7590 dgst_pos3 = 3;
7591 break;
7592
7593 case 500: hash_type = HASH_TYPE_MD5;
7594 salt_type = SALT_TYPE_EMBEDDED;
7595 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7596 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7597 kern_type = KERN_TYPE_MD5CRYPT;
7598 dgst_size = DGST_SIZE_4_4;
7599 parse_func = md5crypt_parse_hash;
7600 sort_by_digest = sort_by_digest_4_4;
7601 opti_type = OPTI_TYPE_ZERO_BYTE;
7602 dgst_pos0 = 0;
7603 dgst_pos1 = 1;
7604 dgst_pos2 = 2;
7605 dgst_pos3 = 3;
7606 break;
7607
7608 case 501: hash_type = HASH_TYPE_MD5;
7609 salt_type = SALT_TYPE_EMBEDDED;
7610 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7611 opts_type = OPTS_TYPE_PT_GENERATE_LE
7612 | OPTS_TYPE_HASH_COPY;
7613 kern_type = KERN_TYPE_MD5CRYPT;
7614 dgst_size = DGST_SIZE_4_4;
7615 parse_func = juniper_parse_hash;
7616 sort_by_digest = sort_by_digest_4_4;
7617 opti_type = OPTI_TYPE_ZERO_BYTE;
7618 dgst_pos0 = 0;
7619 dgst_pos1 = 1;
7620 dgst_pos2 = 2;
7621 dgst_pos3 = 3;
7622 break;
7623
7624 case 900: hash_type = HASH_TYPE_MD4;
7625 salt_type = SALT_TYPE_NONE;
7626 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7627 opts_type = OPTS_TYPE_PT_GENERATE_LE
7628 | OPTS_TYPE_PT_ADD80
7629 | OPTS_TYPE_PT_ADDBITS14;
7630 kern_type = KERN_TYPE_MD4;
7631 dgst_size = DGST_SIZE_4_4;
7632 parse_func = md4_parse_hash;
7633 sort_by_digest = sort_by_digest_4_4;
7634 opti_type = OPTI_TYPE_ZERO_BYTE
7635 | OPTI_TYPE_PRECOMPUTE_INIT
7636 | OPTI_TYPE_PRECOMPUTE_MERKLE
7637 | OPTI_TYPE_MEET_IN_MIDDLE
7638 | OPTI_TYPE_EARLY_SKIP
7639 | OPTI_TYPE_NOT_ITERATED
7640 | OPTI_TYPE_NOT_SALTED
7641 | OPTI_TYPE_RAW_HASH;
7642 dgst_pos0 = 0;
7643 dgst_pos1 = 3;
7644 dgst_pos2 = 2;
7645 dgst_pos3 = 1;
7646 break;
7647
7648 case 1000: hash_type = HASH_TYPE_MD4;
7649 salt_type = SALT_TYPE_NONE;
7650 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7651 opts_type = OPTS_TYPE_PT_GENERATE_LE
7652 | OPTS_TYPE_PT_ADD80
7653 | OPTS_TYPE_PT_ADDBITS14
7654 | OPTS_TYPE_PT_UNICODE;
7655 kern_type = KERN_TYPE_MD4_PWU;
7656 dgst_size = DGST_SIZE_4_4;
7657 parse_func = md4_parse_hash;
7658 sort_by_digest = sort_by_digest_4_4;
7659 opti_type = OPTI_TYPE_ZERO_BYTE
7660 | OPTI_TYPE_PRECOMPUTE_INIT
7661 | OPTI_TYPE_PRECOMPUTE_MERKLE
7662 | OPTI_TYPE_MEET_IN_MIDDLE
7663 | OPTI_TYPE_EARLY_SKIP
7664 | OPTI_TYPE_NOT_ITERATED
7665 | OPTI_TYPE_NOT_SALTED
7666 | OPTI_TYPE_RAW_HASH;
7667 dgst_pos0 = 0;
7668 dgst_pos1 = 3;
7669 dgst_pos2 = 2;
7670 dgst_pos3 = 1;
7671 break;
7672
7673 case 1100: hash_type = HASH_TYPE_MD4;
7674 salt_type = SALT_TYPE_INTERN;
7675 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7676 opts_type = OPTS_TYPE_PT_GENERATE_LE
7677 | OPTS_TYPE_PT_ADD80
7678 | OPTS_TYPE_PT_ADDBITS14
7679 | OPTS_TYPE_PT_UNICODE
7680 | OPTS_TYPE_ST_ADD80
7681 | OPTS_TYPE_ST_UNICODE
7682 | OPTS_TYPE_ST_LOWER;
7683 kern_type = KERN_TYPE_MD44_PWUSLT;
7684 dgst_size = DGST_SIZE_4_4;
7685 parse_func = dcc_parse_hash;
7686 sort_by_digest = sort_by_digest_4_4;
7687 opti_type = OPTI_TYPE_ZERO_BYTE
7688 | OPTI_TYPE_PRECOMPUTE_INIT
7689 | OPTI_TYPE_PRECOMPUTE_MERKLE
7690 | OPTI_TYPE_EARLY_SKIP
7691 | OPTI_TYPE_NOT_ITERATED;
7692 dgst_pos0 = 0;
7693 dgst_pos1 = 3;
7694 dgst_pos2 = 2;
7695 dgst_pos3 = 1;
7696 break;
7697
7698 case 1400: hash_type = HASH_TYPE_SHA256;
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_SHA256;
7705 dgst_size = DGST_SIZE_4_8;
7706 parse_func = sha256_parse_hash;
7707 sort_by_digest = sort_by_digest_4_8;
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 | OPTI_TYPE_RAW_HASH;
7715 dgst_pos0 = 3;
7716 dgst_pos1 = 7;
7717 dgst_pos2 = 2;
7718 dgst_pos3 = 6;
7719 break;
7720
7721 case 1410: hash_type = HASH_TYPE_SHA256;
7722 salt_type = SALT_TYPE_INTERN;
7723 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7724 opts_type = OPTS_TYPE_PT_GENERATE_BE
7725 | OPTS_TYPE_ST_ADD80
7726 | OPTS_TYPE_ST_ADDBITS15;
7727 kern_type = KERN_TYPE_SHA256_PWSLT;
7728 dgst_size = DGST_SIZE_4_8;
7729 parse_func = sha256s_parse_hash;
7730 sort_by_digest = sort_by_digest_4_8;
7731 opti_type = OPTI_TYPE_ZERO_BYTE
7732 | OPTI_TYPE_PRECOMPUTE_INIT
7733 | OPTI_TYPE_PRECOMPUTE_MERKLE
7734 | OPTI_TYPE_EARLY_SKIP
7735 | OPTI_TYPE_NOT_ITERATED
7736 | OPTI_TYPE_APPENDED_SALT
7737 | OPTI_TYPE_RAW_HASH;
7738 dgst_pos0 = 3;
7739 dgst_pos1 = 7;
7740 dgst_pos2 = 2;
7741 dgst_pos3 = 6;
7742 break;
7743
7744 case 1420: hash_type = HASH_TYPE_SHA256;
7745 salt_type = SALT_TYPE_INTERN;
7746 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7747 opts_type = OPTS_TYPE_PT_GENERATE_BE
7748 | OPTS_TYPE_PT_ADD80
7749 | OPTS_TYPE_PT_ADDBITS15;
7750 kern_type = KERN_TYPE_SHA256_SLTPW;
7751 dgst_size = DGST_SIZE_4_8;
7752 parse_func = sha256s_parse_hash;
7753 sort_by_digest = sort_by_digest_4_8;
7754 opti_type = OPTI_TYPE_ZERO_BYTE
7755 | OPTI_TYPE_PRECOMPUTE_INIT
7756 | OPTI_TYPE_PRECOMPUTE_MERKLE
7757 | OPTI_TYPE_EARLY_SKIP
7758 | OPTI_TYPE_NOT_ITERATED
7759 | OPTI_TYPE_PREPENDED_SALT
7760 | OPTI_TYPE_RAW_HASH;
7761 dgst_pos0 = 3;
7762 dgst_pos1 = 7;
7763 dgst_pos2 = 2;
7764 dgst_pos3 = 6;
7765 break;
7766
7767 case 1421: hash_type = HASH_TYPE_SHA256;
7768 salt_type = SALT_TYPE_EMBEDDED;
7769 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7770 opts_type = OPTS_TYPE_PT_GENERATE_BE
7771 | OPTS_TYPE_PT_ADD80
7772 | OPTS_TYPE_PT_ADDBITS15;
7773 kern_type = KERN_TYPE_SHA256_SLTPW;
7774 dgst_size = DGST_SIZE_4_8;
7775 parse_func = hmailserver_parse_hash;
7776 sort_by_digest = sort_by_digest_4_8;
7777 opti_type = OPTI_TYPE_ZERO_BYTE
7778 | OPTI_TYPE_PRECOMPUTE_INIT
7779 | OPTI_TYPE_PRECOMPUTE_MERKLE
7780 | OPTI_TYPE_EARLY_SKIP
7781 | OPTI_TYPE_NOT_ITERATED
7782 | OPTI_TYPE_PREPENDED_SALT
7783 | OPTI_TYPE_RAW_HASH;
7784 dgst_pos0 = 3;
7785 dgst_pos1 = 7;
7786 dgst_pos2 = 2;
7787 dgst_pos3 = 6;
7788 break;
7789
7790 case 1430: hash_type = HASH_TYPE_SHA256;
7791 salt_type = SALT_TYPE_INTERN;
7792 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7793 opts_type = OPTS_TYPE_PT_GENERATE_BE
7794 | OPTS_TYPE_PT_UNICODE
7795 | OPTS_TYPE_ST_ADD80
7796 | OPTS_TYPE_ST_ADDBITS15;
7797 kern_type = KERN_TYPE_SHA256_PWUSLT;
7798 dgst_size = DGST_SIZE_4_8;
7799 parse_func = sha256s_parse_hash;
7800 sort_by_digest = sort_by_digest_4_8;
7801 opti_type = OPTI_TYPE_ZERO_BYTE
7802 | OPTI_TYPE_PRECOMPUTE_INIT
7803 | OPTI_TYPE_PRECOMPUTE_MERKLE
7804 | OPTI_TYPE_EARLY_SKIP
7805 | OPTI_TYPE_NOT_ITERATED
7806 | OPTI_TYPE_APPENDED_SALT
7807 | OPTI_TYPE_RAW_HASH;
7808 dgst_pos0 = 3;
7809 dgst_pos1 = 7;
7810 dgst_pos2 = 2;
7811 dgst_pos3 = 6;
7812 break;
7813
7814 case 1440: hash_type = HASH_TYPE_SHA256;
7815 salt_type = SALT_TYPE_INTERN;
7816 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7817 opts_type = OPTS_TYPE_PT_GENERATE_BE
7818 | OPTS_TYPE_PT_ADD80
7819 | OPTS_TYPE_PT_ADDBITS15
7820 | OPTS_TYPE_PT_UNICODE;
7821 kern_type = KERN_TYPE_SHA256_SLTPWU;
7822 dgst_size = DGST_SIZE_4_8;
7823 parse_func = sha256s_parse_hash;
7824 sort_by_digest = sort_by_digest_4_8;
7825 opti_type = OPTI_TYPE_ZERO_BYTE
7826 | OPTI_TYPE_PRECOMPUTE_INIT
7827 | OPTI_TYPE_PRECOMPUTE_MERKLE
7828 | OPTI_TYPE_EARLY_SKIP
7829 | OPTI_TYPE_NOT_ITERATED
7830 | OPTI_TYPE_PREPENDED_SALT
7831 | OPTI_TYPE_RAW_HASH;
7832 dgst_pos0 = 3;
7833 dgst_pos1 = 7;
7834 dgst_pos2 = 2;
7835 dgst_pos3 = 6;
7836 break;
7837
7838 case 1441: hash_type = HASH_TYPE_SHA256;
7839 salt_type = SALT_TYPE_EMBEDDED;
7840 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7841 opts_type = OPTS_TYPE_PT_GENERATE_BE
7842 | OPTS_TYPE_PT_ADD80
7843 | OPTS_TYPE_PT_ADDBITS15
7844 | OPTS_TYPE_PT_UNICODE
7845 | OPTS_TYPE_ST_BASE64;
7846 kern_type = KERN_TYPE_SHA256_SLTPWU;
7847 dgst_size = DGST_SIZE_4_8;
7848 parse_func = episerver4_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_PREPENDED_SALT
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 1450: 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 kern_type = KERN_TYPE_HMACSHA256_PW;
7869 dgst_size = DGST_SIZE_4_8;
7870 parse_func = hmacsha256_parse_hash;
7871 sort_by_digest = sort_by_digest_4_8;
7872 opti_type = OPTI_TYPE_ZERO_BYTE
7873 | OPTI_TYPE_NOT_ITERATED;
7874 dgst_pos0 = 3;
7875 dgst_pos1 = 7;
7876 dgst_pos2 = 2;
7877 dgst_pos3 = 6;
7878 break;
7879
7880 case 1460: hash_type = HASH_TYPE_SHA256;
7881 salt_type = SALT_TYPE_INTERN;
7882 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7883 opts_type = OPTS_TYPE_PT_GENERATE_BE
7884 | OPTS_TYPE_PT_ADD80
7885 | OPTS_TYPE_PT_ADDBITS15;
7886 kern_type = KERN_TYPE_HMACSHA256_SLT;
7887 dgst_size = DGST_SIZE_4_8;
7888 parse_func = hmacsha256_parse_hash;
7889 sort_by_digest = sort_by_digest_4_8;
7890 opti_type = OPTI_TYPE_ZERO_BYTE
7891 | OPTI_TYPE_NOT_ITERATED;
7892 dgst_pos0 = 3;
7893 dgst_pos1 = 7;
7894 dgst_pos2 = 2;
7895 dgst_pos3 = 6;
7896 break;
7897
7898 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7899 salt_type = SALT_TYPE_EMBEDDED;
7900 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7901 opts_type = OPTS_TYPE_PT_GENERATE_LE
7902 | OPTS_TYPE_PT_BITSLICE;
7903 kern_type = KERN_TYPE_DESCRYPT;
7904 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7905 parse_func = descrypt_parse_hash;
7906 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7907 opti_type = OPTI_TYPE_ZERO_BYTE
7908 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7909 dgst_pos0 = 0;
7910 dgst_pos1 = 1;
7911 dgst_pos2 = 2;
7912 dgst_pos3 = 3;
7913 break;
7914
7915 case 1600: hash_type = HASH_TYPE_MD5;
7916 salt_type = SALT_TYPE_EMBEDDED;
7917 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7918 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7919 kern_type = KERN_TYPE_APR1CRYPT;
7920 dgst_size = DGST_SIZE_4_4;
7921 parse_func = md5apr1_parse_hash;
7922 sort_by_digest = sort_by_digest_4_4;
7923 opti_type = OPTI_TYPE_ZERO_BYTE;
7924 dgst_pos0 = 0;
7925 dgst_pos1 = 1;
7926 dgst_pos2 = 2;
7927 dgst_pos3 = 3;
7928 break;
7929
7930 case 1700: hash_type = HASH_TYPE_SHA512;
7931 salt_type = SALT_TYPE_NONE;
7932 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7933 opts_type = OPTS_TYPE_PT_GENERATE_BE
7934 | OPTS_TYPE_PT_ADD80
7935 | OPTS_TYPE_PT_ADDBITS15;
7936 kern_type = KERN_TYPE_SHA512;
7937 dgst_size = DGST_SIZE_8_8;
7938 parse_func = sha512_parse_hash;
7939 sort_by_digest = sort_by_digest_8_8;
7940 opti_type = OPTI_TYPE_ZERO_BYTE
7941 | OPTI_TYPE_PRECOMPUTE_INIT
7942 | OPTI_TYPE_PRECOMPUTE_MERKLE
7943 | OPTI_TYPE_EARLY_SKIP
7944 | OPTI_TYPE_NOT_ITERATED
7945 | OPTI_TYPE_NOT_SALTED
7946 | OPTI_TYPE_USES_BITS_64
7947 | OPTI_TYPE_RAW_HASH;
7948 dgst_pos0 = 14;
7949 dgst_pos1 = 15;
7950 dgst_pos2 = 6;
7951 dgst_pos3 = 7;
7952 break;
7953
7954 case 1710: hash_type = HASH_TYPE_SHA512;
7955 salt_type = SALT_TYPE_INTERN;
7956 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7957 opts_type = OPTS_TYPE_PT_GENERATE_BE
7958 | OPTS_TYPE_ST_ADD80
7959 | OPTS_TYPE_ST_ADDBITS15;
7960 kern_type = KERN_TYPE_SHA512_PWSLT;
7961 dgst_size = DGST_SIZE_8_8;
7962 parse_func = sha512s_parse_hash;
7963 sort_by_digest = sort_by_digest_8_8;
7964 opti_type = OPTI_TYPE_ZERO_BYTE
7965 | OPTI_TYPE_PRECOMPUTE_INIT
7966 | OPTI_TYPE_PRECOMPUTE_MERKLE
7967 | OPTI_TYPE_EARLY_SKIP
7968 | OPTI_TYPE_NOT_ITERATED
7969 | OPTI_TYPE_APPENDED_SALT
7970 | OPTI_TYPE_USES_BITS_64
7971 | OPTI_TYPE_RAW_HASH;
7972 dgst_pos0 = 14;
7973 dgst_pos1 = 15;
7974 dgst_pos2 = 6;
7975 dgst_pos3 = 7;
7976 break;
7977
7978 case 1711: hash_type = HASH_TYPE_SHA512;
7979 salt_type = SALT_TYPE_EMBEDDED;
7980 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7981 opts_type = OPTS_TYPE_PT_GENERATE_BE
7982 | OPTS_TYPE_ST_ADD80
7983 | OPTS_TYPE_ST_ADDBITS15;
7984 kern_type = KERN_TYPE_SHA512_PWSLT;
7985 dgst_size = DGST_SIZE_8_8;
7986 parse_func = sha512b64s_parse_hash;
7987 sort_by_digest = sort_by_digest_8_8;
7988 opti_type = OPTI_TYPE_ZERO_BYTE
7989 | OPTI_TYPE_PRECOMPUTE_INIT
7990 | OPTI_TYPE_PRECOMPUTE_MERKLE
7991 | OPTI_TYPE_EARLY_SKIP
7992 | OPTI_TYPE_NOT_ITERATED
7993 | OPTI_TYPE_APPENDED_SALT
7994 | OPTI_TYPE_USES_BITS_64
7995 | OPTI_TYPE_RAW_HASH;
7996 dgst_pos0 = 14;
7997 dgst_pos1 = 15;
7998 dgst_pos2 = 6;
7999 dgst_pos3 = 7;
8000 break;
8001
8002 case 1720: hash_type = HASH_TYPE_SHA512;
8003 salt_type = SALT_TYPE_INTERN;
8004 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8005 opts_type = OPTS_TYPE_PT_GENERATE_BE
8006 | OPTS_TYPE_PT_ADD80
8007 | OPTS_TYPE_PT_ADDBITS15;
8008 kern_type = KERN_TYPE_SHA512_SLTPW;
8009 dgst_size = DGST_SIZE_8_8;
8010 parse_func = sha512s_parse_hash;
8011 sort_by_digest = sort_by_digest_8_8;
8012 opti_type = OPTI_TYPE_ZERO_BYTE
8013 | OPTI_TYPE_PRECOMPUTE_INIT
8014 | OPTI_TYPE_PRECOMPUTE_MERKLE
8015 | OPTI_TYPE_EARLY_SKIP
8016 | OPTI_TYPE_NOT_ITERATED
8017 | OPTI_TYPE_PREPENDED_SALT
8018 | OPTI_TYPE_USES_BITS_64
8019 | OPTI_TYPE_RAW_HASH;
8020 dgst_pos0 = 14;
8021 dgst_pos1 = 15;
8022 dgst_pos2 = 6;
8023 dgst_pos3 = 7;
8024 break;
8025
8026 case 1722: hash_type = HASH_TYPE_SHA512;
8027 salt_type = SALT_TYPE_EMBEDDED;
8028 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8029 opts_type = OPTS_TYPE_PT_GENERATE_BE
8030 | OPTS_TYPE_PT_ADD80
8031 | OPTS_TYPE_PT_ADDBITS15
8032 | OPTS_TYPE_ST_HEX;
8033 kern_type = KERN_TYPE_SHA512_SLTPW;
8034 dgst_size = DGST_SIZE_8_8;
8035 parse_func = osx512_parse_hash;
8036 sort_by_digest = sort_by_digest_8_8;
8037 opti_type = OPTI_TYPE_ZERO_BYTE
8038 | OPTI_TYPE_PRECOMPUTE_INIT
8039 | OPTI_TYPE_PRECOMPUTE_MERKLE
8040 | OPTI_TYPE_EARLY_SKIP
8041 | OPTI_TYPE_NOT_ITERATED
8042 | OPTI_TYPE_PREPENDED_SALT
8043 | OPTI_TYPE_USES_BITS_64
8044 | OPTI_TYPE_RAW_HASH;
8045 dgst_pos0 = 14;
8046 dgst_pos1 = 15;
8047 dgst_pos2 = 6;
8048 dgst_pos3 = 7;
8049 break;
8050
8051 case 1730: hash_type = HASH_TYPE_SHA512;
8052 salt_type = SALT_TYPE_INTERN;
8053 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8054 opts_type = OPTS_TYPE_PT_GENERATE_BE
8055 | OPTS_TYPE_PT_UNICODE
8056 | OPTS_TYPE_ST_ADD80
8057 | OPTS_TYPE_ST_ADDBITS15;
8058 kern_type = KERN_TYPE_SHA512_PWSLTU;
8059 dgst_size = DGST_SIZE_8_8;
8060 parse_func = sha512s_parse_hash;
8061 sort_by_digest = sort_by_digest_8_8;
8062 opti_type = OPTI_TYPE_ZERO_BYTE
8063 | OPTI_TYPE_PRECOMPUTE_INIT
8064 | OPTI_TYPE_PRECOMPUTE_MERKLE
8065 | OPTI_TYPE_EARLY_SKIP
8066 | OPTI_TYPE_NOT_ITERATED
8067 | OPTI_TYPE_APPENDED_SALT
8068 | OPTI_TYPE_USES_BITS_64
8069 | OPTI_TYPE_RAW_HASH;
8070 dgst_pos0 = 14;
8071 dgst_pos1 = 15;
8072 dgst_pos2 = 6;
8073 dgst_pos3 = 7;
8074 break;
8075
8076 case 1731: hash_type = HASH_TYPE_SHA512;
8077 salt_type = SALT_TYPE_EMBEDDED;
8078 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8079 opts_type = OPTS_TYPE_PT_GENERATE_BE
8080 | OPTS_TYPE_PT_UNICODE
8081 | OPTS_TYPE_ST_ADD80
8082 | OPTS_TYPE_ST_ADDBITS15
8083 | OPTS_TYPE_ST_HEX;
8084 kern_type = KERN_TYPE_SHA512_PWSLTU;
8085 dgst_size = DGST_SIZE_8_8;
8086 parse_func = mssql2012_parse_hash;
8087 sort_by_digest = sort_by_digest_8_8;
8088 opti_type = OPTI_TYPE_ZERO_BYTE
8089 | OPTI_TYPE_PRECOMPUTE_INIT
8090 | OPTI_TYPE_PRECOMPUTE_MERKLE
8091 | OPTI_TYPE_EARLY_SKIP
8092 | OPTI_TYPE_NOT_ITERATED
8093 | OPTI_TYPE_APPENDED_SALT
8094 | OPTI_TYPE_USES_BITS_64
8095 | OPTI_TYPE_RAW_HASH;
8096 dgst_pos0 = 14;
8097 dgst_pos1 = 15;
8098 dgst_pos2 = 6;
8099 dgst_pos3 = 7;
8100 break;
8101
8102 case 1740: hash_type = HASH_TYPE_SHA512;
8103 salt_type = SALT_TYPE_INTERN;
8104 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8105 opts_type = OPTS_TYPE_PT_GENERATE_BE
8106 | OPTS_TYPE_PT_ADD80
8107 | OPTS_TYPE_PT_ADDBITS15
8108 | OPTS_TYPE_PT_UNICODE;
8109 kern_type = KERN_TYPE_SHA512_SLTPWU;
8110 dgst_size = DGST_SIZE_8_8;
8111 parse_func = sha512s_parse_hash;
8112 sort_by_digest = sort_by_digest_8_8;
8113 opti_type = OPTI_TYPE_ZERO_BYTE
8114 | OPTI_TYPE_PRECOMPUTE_INIT
8115 | OPTI_TYPE_PRECOMPUTE_MERKLE
8116 | OPTI_TYPE_EARLY_SKIP
8117 | OPTI_TYPE_NOT_ITERATED
8118 | OPTI_TYPE_PREPENDED_SALT
8119 | OPTI_TYPE_USES_BITS_64
8120 | OPTI_TYPE_RAW_HASH;
8121 dgst_pos0 = 14;
8122 dgst_pos1 = 15;
8123 dgst_pos2 = 6;
8124 dgst_pos3 = 7;
8125 break;
8126
8127 case 1750: hash_type = HASH_TYPE_SHA512;
8128 salt_type = SALT_TYPE_INTERN;
8129 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8130 opts_type = OPTS_TYPE_PT_GENERATE_BE
8131 | OPTS_TYPE_ST_ADD80;
8132 kern_type = KERN_TYPE_HMACSHA512_PW;
8133 dgst_size = DGST_SIZE_8_8;
8134 parse_func = hmacsha512_parse_hash;
8135 sort_by_digest = sort_by_digest_8_8;
8136 opti_type = OPTI_TYPE_ZERO_BYTE
8137 | OPTI_TYPE_USES_BITS_64
8138 | OPTI_TYPE_NOT_ITERATED;
8139 dgst_pos0 = 14;
8140 dgst_pos1 = 15;
8141 dgst_pos2 = 6;
8142 dgst_pos3 = 7;
8143 break;
8144
8145 case 1760: hash_type = HASH_TYPE_SHA512;
8146 salt_type = SALT_TYPE_INTERN;
8147 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8148 opts_type = OPTS_TYPE_PT_GENERATE_BE
8149 | OPTS_TYPE_PT_ADD80
8150 | OPTS_TYPE_PT_ADDBITS15;
8151 kern_type = KERN_TYPE_HMACSHA512_SLT;
8152 dgst_size = DGST_SIZE_8_8;
8153 parse_func = hmacsha512_parse_hash;
8154 sort_by_digest = sort_by_digest_8_8;
8155 opti_type = OPTI_TYPE_ZERO_BYTE
8156 | OPTI_TYPE_USES_BITS_64
8157 | OPTI_TYPE_NOT_ITERATED;
8158 dgst_pos0 = 14;
8159 dgst_pos1 = 15;
8160 dgst_pos2 = 6;
8161 dgst_pos3 = 7;
8162 break;
8163
8164 case 1800: hash_type = HASH_TYPE_SHA512;
8165 salt_type = SALT_TYPE_EMBEDDED;
8166 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8167 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8168 kern_type = KERN_TYPE_SHA512CRYPT;
8169 dgst_size = DGST_SIZE_8_8;
8170 parse_func = sha512crypt_parse_hash;
8171 sort_by_digest = sort_by_digest_8_8;
8172 opti_type = OPTI_TYPE_ZERO_BYTE
8173 | OPTI_TYPE_USES_BITS_64;
8174 dgst_pos0 = 0;
8175 dgst_pos1 = 1;
8176 dgst_pos2 = 2;
8177 dgst_pos3 = 3;
8178 break;
8179
8180 case 2100: hash_type = HASH_TYPE_DCC2;
8181 salt_type = SALT_TYPE_EMBEDDED;
8182 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8183 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8184 | OPTS_TYPE_ST_LOWER
8185 | OPTS_TYPE_ST_UNICODE;
8186 kern_type = KERN_TYPE_DCC2;
8187 dgst_size = DGST_SIZE_4_4;
8188 parse_func = dcc2_parse_hash;
8189 sort_by_digest = sort_by_digest_4_4;
8190 opti_type = OPTI_TYPE_ZERO_BYTE;
8191 dgst_pos0 = 0;
8192 dgst_pos1 = 1;
8193 dgst_pos2 = 2;
8194 dgst_pos3 = 3;
8195 break;
8196
8197 case 2400: hash_type = HASH_TYPE_MD5;
8198 salt_type = SALT_TYPE_NONE;
8199 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8200 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8201 kern_type = KERN_TYPE_MD5PIX;
8202 dgst_size = DGST_SIZE_4_4;
8203 parse_func = md5pix_parse_hash;
8204 sort_by_digest = sort_by_digest_4_4;
8205 opti_type = OPTI_TYPE_ZERO_BYTE
8206 | OPTI_TYPE_PRECOMPUTE_INIT
8207 | OPTI_TYPE_PRECOMPUTE_MERKLE
8208 | OPTI_TYPE_EARLY_SKIP
8209 | OPTI_TYPE_NOT_ITERATED
8210 | OPTI_TYPE_NOT_SALTED;
8211 dgst_pos0 = 0;
8212 dgst_pos1 = 3;
8213 dgst_pos2 = 2;
8214 dgst_pos3 = 1;
8215 break;
8216
8217 case 2410: hash_type = HASH_TYPE_MD5;
8218 salt_type = SALT_TYPE_INTERN;
8219 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8220 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8221 kern_type = KERN_TYPE_MD5ASA;
8222 dgst_size = DGST_SIZE_4_4;
8223 parse_func = md5asa_parse_hash;
8224 sort_by_digest = sort_by_digest_4_4;
8225 opti_type = OPTI_TYPE_ZERO_BYTE
8226 | OPTI_TYPE_PRECOMPUTE_INIT
8227 | OPTI_TYPE_PRECOMPUTE_MERKLE
8228 | OPTI_TYPE_EARLY_SKIP
8229 | OPTI_TYPE_NOT_ITERATED;
8230 dgst_pos0 = 0;
8231 dgst_pos1 = 3;
8232 dgst_pos2 = 2;
8233 dgst_pos3 = 1;
8234 break;
8235
8236 case 2500: hash_type = HASH_TYPE_WPA;
8237 salt_type = SALT_TYPE_EMBEDDED;
8238 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8239 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8240 kern_type = KERN_TYPE_WPA;
8241 dgst_size = DGST_SIZE_4_4;
8242 parse_func = wpa_parse_hash;
8243 sort_by_digest = sort_by_digest_4_4;
8244 opti_type = OPTI_TYPE_ZERO_BYTE;
8245 dgst_pos0 = 0;
8246 dgst_pos1 = 1;
8247 dgst_pos2 = 2;
8248 dgst_pos3 = 3;
8249 break;
8250
8251 case 2600: hash_type = HASH_TYPE_MD5;
8252 salt_type = SALT_TYPE_VIRTUAL;
8253 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8254 opts_type = OPTS_TYPE_PT_GENERATE_LE
8255 | OPTS_TYPE_PT_ADD80
8256 | OPTS_TYPE_PT_ADDBITS14
8257 | OPTS_TYPE_ST_ADD80;
8258 kern_type = KERN_TYPE_MD55_PWSLT1;
8259 dgst_size = DGST_SIZE_4_4;
8260 parse_func = md5md5_parse_hash;
8261 sort_by_digest = sort_by_digest_4_4;
8262 opti_type = OPTI_TYPE_ZERO_BYTE
8263 | OPTI_TYPE_PRECOMPUTE_INIT
8264 | OPTI_TYPE_PRECOMPUTE_MERKLE
8265 | OPTI_TYPE_EARLY_SKIP;
8266 dgst_pos0 = 0;
8267 dgst_pos1 = 3;
8268 dgst_pos2 = 2;
8269 dgst_pos3 = 1;
8270 break;
8271
8272 case 2611: hash_type = HASH_TYPE_MD5;
8273 salt_type = SALT_TYPE_INTERN;
8274 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8275 opts_type = OPTS_TYPE_PT_GENERATE_LE
8276 | OPTS_TYPE_PT_ADD80
8277 | OPTS_TYPE_PT_ADDBITS14
8278 | OPTS_TYPE_ST_ADD80;
8279 kern_type = KERN_TYPE_MD55_PWSLT1;
8280 dgst_size = DGST_SIZE_4_4;
8281 parse_func = vb3_parse_hash;
8282 sort_by_digest = sort_by_digest_4_4;
8283 opti_type = OPTI_TYPE_ZERO_BYTE
8284 | OPTI_TYPE_PRECOMPUTE_INIT
8285 | OPTI_TYPE_PRECOMPUTE_MERKLE
8286 | OPTI_TYPE_EARLY_SKIP;
8287 dgst_pos0 = 0;
8288 dgst_pos1 = 3;
8289 dgst_pos2 = 2;
8290 dgst_pos3 = 1;
8291 break;
8292
8293 case 2612: hash_type = HASH_TYPE_MD5;
8294 salt_type = SALT_TYPE_EMBEDDED;
8295 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8296 opts_type = OPTS_TYPE_PT_GENERATE_LE
8297 | OPTS_TYPE_PT_ADD80
8298 | OPTS_TYPE_PT_ADDBITS14
8299 | OPTS_TYPE_ST_ADD80
8300 | OPTS_TYPE_ST_HEX;
8301 kern_type = KERN_TYPE_MD55_PWSLT1;
8302 dgst_size = DGST_SIZE_4_4;
8303 parse_func = phps_parse_hash;
8304 sort_by_digest = sort_by_digest_4_4;
8305 opti_type = OPTI_TYPE_ZERO_BYTE
8306 | OPTI_TYPE_PRECOMPUTE_INIT
8307 | OPTI_TYPE_PRECOMPUTE_MERKLE
8308 | OPTI_TYPE_EARLY_SKIP;
8309 dgst_pos0 = 0;
8310 dgst_pos1 = 3;
8311 dgst_pos2 = 2;
8312 dgst_pos3 = 1;
8313 break;
8314
8315 case 2711: hash_type = HASH_TYPE_MD5;
8316 salt_type = SALT_TYPE_INTERN;
8317 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8318 opts_type = OPTS_TYPE_PT_GENERATE_LE
8319 | OPTS_TYPE_PT_ADD80
8320 | OPTS_TYPE_PT_ADDBITS14
8321 | OPTS_TYPE_ST_ADD80;
8322 kern_type = KERN_TYPE_MD55_PWSLT2;
8323 dgst_size = DGST_SIZE_4_4;
8324 parse_func = vb30_parse_hash;
8325 sort_by_digest = sort_by_digest_4_4;
8326 opti_type = OPTI_TYPE_ZERO_BYTE
8327 | OPTI_TYPE_PRECOMPUTE_INIT
8328 | OPTI_TYPE_EARLY_SKIP;
8329 dgst_pos0 = 0;
8330 dgst_pos1 = 3;
8331 dgst_pos2 = 2;
8332 dgst_pos3 = 1;
8333 break;
8334
8335 case 2811: hash_type = HASH_TYPE_MD5;
8336 salt_type = SALT_TYPE_INTERN;
8337 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8338 opts_type = OPTS_TYPE_PT_GENERATE_LE
8339 | OPTS_TYPE_PT_ADD80
8340 | OPTS_TYPE_PT_ADDBITS14;
8341 kern_type = KERN_TYPE_MD55_SLTPW;
8342 dgst_size = DGST_SIZE_4_4;
8343 parse_func = ipb2_parse_hash;
8344 sort_by_digest = sort_by_digest_4_4;
8345 opti_type = OPTI_TYPE_ZERO_BYTE
8346 | OPTI_TYPE_PRECOMPUTE_INIT
8347 | OPTI_TYPE_EARLY_SKIP;
8348 dgst_pos0 = 0;
8349 dgst_pos1 = 3;
8350 dgst_pos2 = 2;
8351 dgst_pos3 = 1;
8352 break;
8353
8354 case 3000: hash_type = HASH_TYPE_LM;
8355 salt_type = SALT_TYPE_NONE;
8356 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8357 opts_type = OPTS_TYPE_PT_GENERATE_LE
8358 | OPTS_TYPE_PT_UPPER
8359 | OPTS_TYPE_PT_BITSLICE;
8360 kern_type = KERN_TYPE_LM;
8361 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8362 parse_func = lm_parse_hash;
8363 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8364 opti_type = OPTI_TYPE_ZERO_BYTE
8365 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8366 dgst_pos0 = 0;
8367 dgst_pos1 = 1;
8368 dgst_pos2 = 2;
8369 dgst_pos3 = 3;
8370 break;
8371
8372 case 3100: hash_type = HASH_TYPE_ORACLEH;
8373 salt_type = SALT_TYPE_INTERN;
8374 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8375 opts_type = OPTS_TYPE_PT_GENERATE_LE
8376 | OPTS_TYPE_PT_UPPER
8377 | OPTS_TYPE_ST_UPPER;
8378 kern_type = KERN_TYPE_ORACLEH;
8379 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8380 parse_func = oracleh_parse_hash;
8381 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8382 opti_type = OPTI_TYPE_ZERO_BYTE;
8383 dgst_pos0 = 0;
8384 dgst_pos1 = 1;
8385 dgst_pos2 = 2;
8386 dgst_pos3 = 3;
8387 break;
8388
8389 case 3200: hash_type = HASH_TYPE_BCRYPT;
8390 salt_type = SALT_TYPE_EMBEDDED;
8391 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8392 opts_type = OPTS_TYPE_PT_GENERATE_LE
8393 | OPTS_TYPE_ST_GENERATE_LE;
8394 kern_type = KERN_TYPE_BCRYPT;
8395 dgst_size = DGST_SIZE_4_6;
8396 parse_func = bcrypt_parse_hash;
8397 sort_by_digest = sort_by_digest_4_6;
8398 opti_type = OPTI_TYPE_ZERO_BYTE;
8399 dgst_pos0 = 0;
8400 dgst_pos1 = 1;
8401 dgst_pos2 = 2;
8402 dgst_pos3 = 3;
8403 break;
8404
8405 case 3710: hash_type = HASH_TYPE_MD5;
8406 salt_type = SALT_TYPE_INTERN;
8407 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8408 opts_type = OPTS_TYPE_PT_GENERATE_LE
8409 | OPTS_TYPE_PT_ADD80
8410 | OPTS_TYPE_PT_ADDBITS14;
8411 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8412 dgst_size = DGST_SIZE_4_4;
8413 parse_func = md5s_parse_hash;
8414 sort_by_digest = sort_by_digest_4_4;
8415 opti_type = OPTI_TYPE_ZERO_BYTE
8416 | OPTI_TYPE_PRECOMPUTE_INIT
8417 | OPTI_TYPE_PRECOMPUTE_MERKLE
8418 | OPTI_TYPE_EARLY_SKIP;
8419 dgst_pos0 = 0;
8420 dgst_pos1 = 3;
8421 dgst_pos2 = 2;
8422 dgst_pos3 = 1;
8423 break;
8424
8425 case 3711: hash_type = HASH_TYPE_MD5;
8426 salt_type = SALT_TYPE_EMBEDDED;
8427 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8428 opts_type = OPTS_TYPE_PT_GENERATE_LE
8429 | OPTS_TYPE_PT_ADD80
8430 | OPTS_TYPE_PT_ADDBITS14;
8431 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8432 dgst_size = DGST_SIZE_4_4;
8433 parse_func = mediawiki_b_parse_hash;
8434 sort_by_digest = sort_by_digest_4_4;
8435 opti_type = OPTI_TYPE_ZERO_BYTE
8436 | OPTI_TYPE_PRECOMPUTE_INIT
8437 | OPTI_TYPE_PRECOMPUTE_MERKLE
8438 | OPTI_TYPE_EARLY_SKIP;
8439 dgst_pos0 = 0;
8440 dgst_pos1 = 3;
8441 dgst_pos2 = 2;
8442 dgst_pos3 = 1;
8443 break;
8444
8445 case 3800: hash_type = HASH_TYPE_MD5;
8446 salt_type = SALT_TYPE_INTERN;
8447 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8448 opts_type = OPTS_TYPE_PT_GENERATE_LE
8449 | OPTS_TYPE_ST_ADDBITS14;
8450 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8451 dgst_size = DGST_SIZE_4_4;
8452 parse_func = md5s_parse_hash;
8453 sort_by_digest = sort_by_digest_4_4;
8454 opti_type = OPTI_TYPE_ZERO_BYTE
8455 | OPTI_TYPE_PRECOMPUTE_INIT
8456 | OPTI_TYPE_PRECOMPUTE_MERKLE
8457 | OPTI_TYPE_EARLY_SKIP
8458 | OPTI_TYPE_NOT_ITERATED
8459 | OPTI_TYPE_RAW_HASH;
8460 dgst_pos0 = 0;
8461 dgst_pos1 = 3;
8462 dgst_pos2 = 2;
8463 dgst_pos3 = 1;
8464 break;
8465
8466 case 4300: hash_type = HASH_TYPE_MD5;
8467 salt_type = SALT_TYPE_VIRTUAL;
8468 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8469 opts_type = OPTS_TYPE_PT_GENERATE_LE
8470 | OPTS_TYPE_PT_ADD80
8471 | OPTS_TYPE_PT_ADDBITS14
8472 | OPTS_TYPE_ST_ADD80;
8473 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8474 dgst_size = DGST_SIZE_4_4;
8475 parse_func = md5md5_parse_hash;
8476 sort_by_digest = sort_by_digest_4_4;
8477 opti_type = OPTI_TYPE_ZERO_BYTE
8478 | OPTI_TYPE_PRECOMPUTE_INIT
8479 | OPTI_TYPE_PRECOMPUTE_MERKLE
8480 | OPTI_TYPE_EARLY_SKIP;
8481 dgst_pos0 = 0;
8482 dgst_pos1 = 3;
8483 dgst_pos2 = 2;
8484 dgst_pos3 = 1;
8485 break;
8486
8487
8488 case 4400: hash_type = HASH_TYPE_MD5;
8489 salt_type = SALT_TYPE_NONE;
8490 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8491 opts_type = OPTS_TYPE_PT_GENERATE_BE
8492 | OPTS_TYPE_PT_ADD80
8493 | OPTS_TYPE_PT_ADDBITS15;
8494 kern_type = KERN_TYPE_MD5_SHA1;
8495 dgst_size = DGST_SIZE_4_4;
8496 parse_func = md5_parse_hash;
8497 sort_by_digest = sort_by_digest_4_4;
8498 opti_type = OPTI_TYPE_ZERO_BYTE
8499 | OPTI_TYPE_PRECOMPUTE_INIT
8500 | OPTI_TYPE_PRECOMPUTE_MERKLE
8501 | OPTI_TYPE_EARLY_SKIP
8502 | OPTI_TYPE_NOT_ITERATED
8503 | OPTI_TYPE_NOT_SALTED
8504 | OPTI_TYPE_RAW_HASH;
8505 dgst_pos0 = 0;
8506 dgst_pos1 = 3;
8507 dgst_pos2 = 2;
8508 dgst_pos3 = 1;
8509 break;
8510
8511 case 4500: hash_type = HASH_TYPE_SHA1;
8512 salt_type = SALT_TYPE_NONE;
8513 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8514 opts_type = OPTS_TYPE_PT_GENERATE_BE
8515 | OPTS_TYPE_PT_ADD80
8516 | OPTS_TYPE_PT_ADDBITS15;
8517 kern_type = KERN_TYPE_SHA11;
8518 dgst_size = DGST_SIZE_4_5;
8519 parse_func = sha1_parse_hash;
8520 sort_by_digest = sort_by_digest_4_5;
8521 opti_type = OPTI_TYPE_ZERO_BYTE
8522 | OPTI_TYPE_PRECOMPUTE_INIT
8523 | OPTI_TYPE_PRECOMPUTE_MERKLE
8524 | OPTI_TYPE_EARLY_SKIP
8525 | OPTI_TYPE_NOT_SALTED;
8526 dgst_pos0 = 3;
8527 dgst_pos1 = 4;
8528 dgst_pos2 = 2;
8529 dgst_pos3 = 1;
8530 break;
8531
8532 case 4700: hash_type = HASH_TYPE_SHA1;
8533 salt_type = SALT_TYPE_NONE;
8534 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8535 opts_type = OPTS_TYPE_PT_GENERATE_LE
8536 | OPTS_TYPE_PT_ADD80
8537 | OPTS_TYPE_PT_ADDBITS14;
8538 kern_type = KERN_TYPE_SHA1_MD5;
8539 dgst_size = DGST_SIZE_4_5;
8540 parse_func = sha1_parse_hash;
8541 sort_by_digest = sort_by_digest_4_5;
8542 opti_type = OPTI_TYPE_ZERO_BYTE
8543 | OPTI_TYPE_PRECOMPUTE_INIT
8544 | OPTI_TYPE_PRECOMPUTE_MERKLE
8545 | OPTI_TYPE_EARLY_SKIP
8546 | OPTI_TYPE_NOT_ITERATED
8547 | OPTI_TYPE_NOT_SALTED
8548 | OPTI_TYPE_RAW_HASH;
8549 dgst_pos0 = 3;
8550 dgst_pos1 = 4;
8551 dgst_pos2 = 2;
8552 dgst_pos3 = 1;
8553 break;
8554
8555 case 4800: hash_type = HASH_TYPE_MD5;
8556 salt_type = SALT_TYPE_EMBEDDED;
8557 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8558 opts_type = OPTS_TYPE_PT_GENERATE_LE
8559 | OPTS_TYPE_PT_ADDBITS14;
8560 kern_type = KERN_TYPE_MD5_CHAP;
8561 dgst_size = DGST_SIZE_4_4;
8562 parse_func = chap_parse_hash;
8563 sort_by_digest = sort_by_digest_4_4;
8564 opti_type = OPTI_TYPE_ZERO_BYTE
8565 | OPTI_TYPE_PRECOMPUTE_INIT
8566 | OPTI_TYPE_PRECOMPUTE_MERKLE
8567 | OPTI_TYPE_MEET_IN_MIDDLE
8568 | OPTI_TYPE_EARLY_SKIP
8569 | OPTI_TYPE_NOT_ITERATED
8570 | OPTI_TYPE_RAW_HASH;
8571 dgst_pos0 = 0;
8572 dgst_pos1 = 3;
8573 dgst_pos2 = 2;
8574 dgst_pos3 = 1;
8575 break;
8576
8577 case 4900: hash_type = HASH_TYPE_SHA1;
8578 salt_type = SALT_TYPE_INTERN;
8579 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8580 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8581 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8582 dgst_size = DGST_SIZE_4_5;
8583 parse_func = sha1s_parse_hash;
8584 sort_by_digest = sort_by_digest_4_5;
8585 opti_type = OPTI_TYPE_ZERO_BYTE
8586 | OPTI_TYPE_PRECOMPUTE_INIT
8587 | OPTI_TYPE_PRECOMPUTE_MERKLE
8588 | OPTI_TYPE_EARLY_SKIP;
8589 dgst_pos0 = 3;
8590 dgst_pos1 = 4;
8591 dgst_pos2 = 2;
8592 dgst_pos3 = 1;
8593 break;
8594
8595 case 5000: hash_type = HASH_TYPE_KECCAK;
8596 salt_type = SALT_TYPE_EMBEDDED;
8597 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8598 opts_type = OPTS_TYPE_PT_GENERATE_LE
8599 | OPTS_TYPE_PT_ADD01;
8600 kern_type = KERN_TYPE_KECCAK;
8601 dgst_size = DGST_SIZE_8_25;
8602 parse_func = keccak_parse_hash;
8603 sort_by_digest = sort_by_digest_8_25;
8604 opti_type = OPTI_TYPE_ZERO_BYTE
8605 | OPTI_TYPE_USES_BITS_64
8606 | OPTI_TYPE_RAW_HASH;
8607 dgst_pos0 = 2;
8608 dgst_pos1 = 3;
8609 dgst_pos2 = 4;
8610 dgst_pos3 = 5;
8611 break;
8612
8613 case 5100: hash_type = HASH_TYPE_MD5H;
8614 salt_type = SALT_TYPE_NONE;
8615 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8616 opts_type = OPTS_TYPE_PT_GENERATE_LE
8617 | OPTS_TYPE_PT_ADD80
8618 | OPTS_TYPE_PT_ADDBITS14;
8619 kern_type = KERN_TYPE_MD5H;
8620 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8621 parse_func = md5half_parse_hash;
8622 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8623 opti_type = OPTI_TYPE_ZERO_BYTE
8624 | OPTI_TYPE_RAW_HASH;
8625 dgst_pos0 = 0;
8626 dgst_pos1 = 1;
8627 dgst_pos2 = 2;
8628 dgst_pos3 = 3;
8629 break;
8630
8631 case 5200: hash_type = HASH_TYPE_SHA256;
8632 salt_type = SALT_TYPE_EMBEDDED;
8633 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8634 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8635 kern_type = KERN_TYPE_PSAFE3;
8636 dgst_size = DGST_SIZE_4_8;
8637 parse_func = psafe3_parse_hash;
8638 sort_by_digest = sort_by_digest_4_8;
8639 opti_type = OPTI_TYPE_ZERO_BYTE;
8640 dgst_pos0 = 0;
8641 dgst_pos1 = 1;
8642 dgst_pos2 = 2;
8643 dgst_pos3 = 3;
8644 break;
8645
8646 case 5300: hash_type = HASH_TYPE_MD5;
8647 salt_type = SALT_TYPE_EMBEDDED;
8648 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8649 opts_type = OPTS_TYPE_PT_GENERATE_LE
8650 | OPTS_TYPE_ST_ADD80;
8651 kern_type = KERN_TYPE_IKEPSK_MD5;
8652 dgst_size = DGST_SIZE_4_4;
8653 parse_func = ikepsk_md5_parse_hash;
8654 sort_by_digest = sort_by_digest_4_4;
8655 opti_type = OPTI_TYPE_ZERO_BYTE;
8656 dgst_pos0 = 0;
8657 dgst_pos1 = 3;
8658 dgst_pos2 = 2;
8659 dgst_pos3 = 1;
8660 break;
8661
8662 case 5400: hash_type = HASH_TYPE_SHA1;
8663 salt_type = SALT_TYPE_EMBEDDED;
8664 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8665 opts_type = OPTS_TYPE_PT_GENERATE_BE
8666 | OPTS_TYPE_ST_ADD80;
8667 kern_type = KERN_TYPE_IKEPSK_SHA1;
8668 dgst_size = DGST_SIZE_4_5;
8669 parse_func = ikepsk_sha1_parse_hash;
8670 sort_by_digest = sort_by_digest_4_5;
8671 opti_type = OPTI_TYPE_ZERO_BYTE;
8672 dgst_pos0 = 3;
8673 dgst_pos1 = 4;
8674 dgst_pos2 = 2;
8675 dgst_pos3 = 1;
8676 break;
8677
8678 case 5500: hash_type = HASH_TYPE_NETNTLM;
8679 salt_type = SALT_TYPE_EMBEDDED;
8680 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8681 opts_type = OPTS_TYPE_PT_GENERATE_LE
8682 | OPTS_TYPE_PT_ADD80
8683 | OPTS_TYPE_PT_ADDBITS14
8684 | OPTS_TYPE_PT_UNICODE
8685 | OPTS_TYPE_ST_HEX;
8686 kern_type = KERN_TYPE_NETNTLMv1;
8687 dgst_size = DGST_SIZE_4_4;
8688 parse_func = netntlmv1_parse_hash;
8689 sort_by_digest = sort_by_digest_4_4;
8690 opti_type = OPTI_TYPE_ZERO_BYTE
8691 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8692 dgst_pos0 = 0;
8693 dgst_pos1 = 1;
8694 dgst_pos2 = 2;
8695 dgst_pos3 = 3;
8696 break;
8697
8698 case 5600: hash_type = HASH_TYPE_MD5;
8699 salt_type = SALT_TYPE_EMBEDDED;
8700 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8701 opts_type = OPTS_TYPE_PT_GENERATE_LE
8702 | OPTS_TYPE_PT_ADD80
8703 | OPTS_TYPE_PT_ADDBITS14
8704 | OPTS_TYPE_PT_UNICODE;
8705 kern_type = KERN_TYPE_NETNTLMv2;
8706 dgst_size = DGST_SIZE_4_4;
8707 parse_func = netntlmv2_parse_hash;
8708 sort_by_digest = sort_by_digest_4_4;
8709 opti_type = OPTI_TYPE_ZERO_BYTE;
8710 dgst_pos0 = 0;
8711 dgst_pos1 = 3;
8712 dgst_pos2 = 2;
8713 dgst_pos3 = 1;
8714 break;
8715
8716 case 5700: hash_type = HASH_TYPE_SHA256;
8717 salt_type = SALT_TYPE_NONE;
8718 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8719 opts_type = OPTS_TYPE_PT_GENERATE_BE
8720 | OPTS_TYPE_PT_ADD80
8721 | OPTS_TYPE_PT_ADDBITS15;
8722 kern_type = KERN_TYPE_SHA256;
8723 dgst_size = DGST_SIZE_4_8;
8724 parse_func = cisco4_parse_hash;
8725 sort_by_digest = sort_by_digest_4_8;
8726 opti_type = OPTI_TYPE_ZERO_BYTE
8727 | OPTI_TYPE_PRECOMPUTE_INIT
8728 | OPTI_TYPE_PRECOMPUTE_MERKLE
8729 | OPTI_TYPE_EARLY_SKIP
8730 | OPTI_TYPE_NOT_ITERATED
8731 | OPTI_TYPE_NOT_SALTED
8732 | OPTI_TYPE_RAW_HASH;
8733 dgst_pos0 = 3;
8734 dgst_pos1 = 7;
8735 dgst_pos2 = 2;
8736 dgst_pos3 = 6;
8737 break;
8738
8739 case 5800: hash_type = HASH_TYPE_SHA1;
8740 salt_type = SALT_TYPE_INTERN;
8741 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8742 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8743 | OPTS_TYPE_ST_ADD80;
8744 kern_type = KERN_TYPE_ANDROIDPIN;
8745 dgst_size = DGST_SIZE_4_5;
8746 parse_func = androidpin_parse_hash;
8747 sort_by_digest = sort_by_digest_4_5;
8748 opti_type = OPTI_TYPE_ZERO_BYTE;
8749 dgst_pos0 = 0;
8750 dgst_pos1 = 1;
8751 dgst_pos2 = 2;
8752 dgst_pos3 = 3;
8753 break;
8754
8755 case 6000: hash_type = HASH_TYPE_RIPEMD160;
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 kern_type = KERN_TYPE_RIPEMD160;
8761 dgst_size = DGST_SIZE_4_5;
8762 parse_func = ripemd160_parse_hash;
8763 sort_by_digest = sort_by_digest_4_5;
8764 opti_type = OPTI_TYPE_ZERO_BYTE;
8765 dgst_pos0 = 0;
8766 dgst_pos1 = 1;
8767 dgst_pos2 = 2;
8768 dgst_pos3 = 3;
8769 break;
8770
8771 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8772 salt_type = SALT_TYPE_NONE;
8773 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8774 opts_type = OPTS_TYPE_PT_GENERATE_BE
8775 | OPTS_TYPE_PT_ADD80;
8776 kern_type = KERN_TYPE_WHIRLPOOL;
8777 dgst_size = DGST_SIZE_4_16;
8778 parse_func = whirlpool_parse_hash;
8779 sort_by_digest = sort_by_digest_4_16;
8780 opti_type = OPTI_TYPE_ZERO_BYTE;
8781 dgst_pos0 = 0;
8782 dgst_pos1 = 1;
8783 dgst_pos2 = 2;
8784 dgst_pos3 = 3;
8785 break;
8786
8787 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8788 salt_type = SALT_TYPE_EMBEDDED;
8789 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8790 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8791 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8792 dgst_size = DGST_SIZE_4_5;
8793 parse_func = truecrypt_parse_hash_2k;
8794 sort_by_digest = sort_by_digest_4_5;
8795 opti_type = OPTI_TYPE_ZERO_BYTE;
8796 dgst_pos0 = 0;
8797 dgst_pos1 = 1;
8798 dgst_pos2 = 2;
8799 dgst_pos3 = 3;
8800 break;
8801
8802 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8803 salt_type = SALT_TYPE_EMBEDDED;
8804 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8805 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8806 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8807 dgst_size = DGST_SIZE_4_5;
8808 parse_func = truecrypt_parse_hash_2k;
8809 sort_by_digest = sort_by_digest_4_5;
8810 opti_type = OPTI_TYPE_ZERO_BYTE;
8811 dgst_pos0 = 0;
8812 dgst_pos1 = 1;
8813 dgst_pos2 = 2;
8814 dgst_pos3 = 3;
8815 break;
8816
8817 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8818 salt_type = SALT_TYPE_EMBEDDED;
8819 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8820 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8821 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8822 dgst_size = DGST_SIZE_4_5;
8823 parse_func = truecrypt_parse_hash_2k;
8824 sort_by_digest = sort_by_digest_4_5;
8825 opti_type = OPTI_TYPE_ZERO_BYTE;
8826 dgst_pos0 = 0;
8827 dgst_pos1 = 1;
8828 dgst_pos2 = 2;
8829 dgst_pos3 = 3;
8830 break;
8831
8832 case 6221: hash_type = HASH_TYPE_SHA512;
8833 salt_type = SALT_TYPE_EMBEDDED;
8834 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8835 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8836 kern_type = KERN_TYPE_TCSHA512_XTS512;
8837 dgst_size = DGST_SIZE_8_8;
8838 parse_func = truecrypt_parse_hash_1k;
8839 sort_by_digest = sort_by_digest_8_8;
8840 opti_type = OPTI_TYPE_ZERO_BYTE
8841 | OPTI_TYPE_USES_BITS_64;
8842 dgst_pos0 = 0;
8843 dgst_pos1 = 1;
8844 dgst_pos2 = 2;
8845 dgst_pos3 = 3;
8846 break;
8847
8848 case 6222: hash_type = HASH_TYPE_SHA512;
8849 salt_type = SALT_TYPE_EMBEDDED;
8850 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8851 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8852 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8853 dgst_size = DGST_SIZE_8_8;
8854 parse_func = truecrypt_parse_hash_1k;
8855 sort_by_digest = sort_by_digest_8_8;
8856 opti_type = OPTI_TYPE_ZERO_BYTE
8857 | OPTI_TYPE_USES_BITS_64;
8858 dgst_pos0 = 0;
8859 dgst_pos1 = 1;
8860 dgst_pos2 = 2;
8861 dgst_pos3 = 3;
8862 break;
8863
8864 case 6223: hash_type = HASH_TYPE_SHA512;
8865 salt_type = SALT_TYPE_EMBEDDED;
8866 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8867 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8868 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8869 dgst_size = DGST_SIZE_8_8;
8870 parse_func = truecrypt_parse_hash_1k;
8871 sort_by_digest = sort_by_digest_8_8;
8872 opti_type = OPTI_TYPE_ZERO_BYTE
8873 | OPTI_TYPE_USES_BITS_64;
8874 dgst_pos0 = 0;
8875 dgst_pos1 = 1;
8876 dgst_pos2 = 2;
8877 dgst_pos3 = 3;
8878 break;
8879
8880 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8881 salt_type = SALT_TYPE_EMBEDDED;
8882 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8883 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8884 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8885 dgst_size = DGST_SIZE_4_8;
8886 parse_func = truecrypt_parse_hash_1k;
8887 sort_by_digest = sort_by_digest_4_8;
8888 opti_type = OPTI_TYPE_ZERO_BYTE;
8889 dgst_pos0 = 0;
8890 dgst_pos1 = 1;
8891 dgst_pos2 = 2;
8892 dgst_pos3 = 3;
8893 break;
8894
8895 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8896 salt_type = SALT_TYPE_EMBEDDED;
8897 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8898 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8899 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8900 dgst_size = DGST_SIZE_4_8;
8901 parse_func = truecrypt_parse_hash_1k;
8902 sort_by_digest = sort_by_digest_4_8;
8903 opti_type = OPTI_TYPE_ZERO_BYTE;
8904 dgst_pos0 = 0;
8905 dgst_pos1 = 1;
8906 dgst_pos2 = 2;
8907 dgst_pos3 = 3;
8908 break;
8909
8910 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8911 salt_type = SALT_TYPE_EMBEDDED;
8912 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8913 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8914 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8915 dgst_size = DGST_SIZE_4_8;
8916 parse_func = truecrypt_parse_hash_1k;
8917 sort_by_digest = sort_by_digest_4_8;
8918 opti_type = OPTI_TYPE_ZERO_BYTE;
8919 dgst_pos0 = 0;
8920 dgst_pos1 = 1;
8921 dgst_pos2 = 2;
8922 dgst_pos3 = 3;
8923 break;
8924
8925 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8926 salt_type = SALT_TYPE_EMBEDDED;
8927 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8928 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8929 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8930 dgst_size = DGST_SIZE_4_5;
8931 parse_func = truecrypt_parse_hash_1k;
8932 sort_by_digest = sort_by_digest_4_5;
8933 opti_type = OPTI_TYPE_ZERO_BYTE;
8934 dgst_pos0 = 0;
8935 dgst_pos1 = 1;
8936 dgst_pos2 = 2;
8937 dgst_pos3 = 3;
8938 break;
8939
8940 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8941 salt_type = SALT_TYPE_EMBEDDED;
8942 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8943 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8944 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8945 dgst_size = DGST_SIZE_4_5;
8946 parse_func = truecrypt_parse_hash_1k;
8947 sort_by_digest = sort_by_digest_4_5;
8948 opti_type = OPTI_TYPE_ZERO_BYTE;
8949 dgst_pos0 = 0;
8950 dgst_pos1 = 1;
8951 dgst_pos2 = 2;
8952 dgst_pos3 = 3;
8953 break;
8954
8955 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8956 salt_type = SALT_TYPE_EMBEDDED;
8957 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8958 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8959 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8960 dgst_size = DGST_SIZE_4_5;
8961 parse_func = truecrypt_parse_hash_1k;
8962 sort_by_digest = sort_by_digest_4_5;
8963 opti_type = OPTI_TYPE_ZERO_BYTE;
8964 dgst_pos0 = 0;
8965 dgst_pos1 = 1;
8966 dgst_pos2 = 2;
8967 dgst_pos3 = 3;
8968 break;
8969
8970 case 6300: hash_type = HASH_TYPE_MD5;
8971 salt_type = SALT_TYPE_EMBEDDED;
8972 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8973 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8974 kern_type = KERN_TYPE_MD5AIX;
8975 dgst_size = DGST_SIZE_4_4;
8976 parse_func = md5aix_parse_hash;
8977 sort_by_digest = sort_by_digest_4_4;
8978 opti_type = OPTI_TYPE_ZERO_BYTE;
8979 dgst_pos0 = 0;
8980 dgst_pos1 = 1;
8981 dgst_pos2 = 2;
8982 dgst_pos3 = 3;
8983 break;
8984
8985 case 6400: hash_type = HASH_TYPE_SHA256;
8986 salt_type = SALT_TYPE_EMBEDDED;
8987 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8988 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8989 kern_type = KERN_TYPE_SHA256AIX;
8990 dgst_size = DGST_SIZE_4_8;
8991 parse_func = sha256aix_parse_hash;
8992 sort_by_digest = sort_by_digest_4_8;
8993 opti_type = OPTI_TYPE_ZERO_BYTE;
8994 dgst_pos0 = 0;
8995 dgst_pos1 = 1;
8996 dgst_pos2 = 2;
8997 dgst_pos3 = 3;
8998 break;
8999
9000 case 6500: hash_type = HASH_TYPE_SHA512;
9001 salt_type = SALT_TYPE_EMBEDDED;
9002 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9003 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9004 kern_type = KERN_TYPE_SHA512AIX;
9005 dgst_size = DGST_SIZE_8_8;
9006 parse_func = sha512aix_parse_hash;
9007 sort_by_digest = sort_by_digest_8_8;
9008 opti_type = OPTI_TYPE_ZERO_BYTE
9009 | OPTI_TYPE_USES_BITS_64;
9010 dgst_pos0 = 0;
9011 dgst_pos1 = 1;
9012 dgst_pos2 = 2;
9013 dgst_pos3 = 3;
9014 break;
9015
9016 case 6600: hash_type = HASH_TYPE_AES;
9017 salt_type = SALT_TYPE_EMBEDDED;
9018 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9019 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9020 kern_type = KERN_TYPE_AGILEKEY;
9021 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9022 parse_func = agilekey_parse_hash;
9023 sort_by_digest = sort_by_digest_4_5;
9024 opti_type = OPTI_TYPE_ZERO_BYTE;
9025 dgst_pos0 = 0;
9026 dgst_pos1 = 1;
9027 dgst_pos2 = 2;
9028 dgst_pos3 = 3;
9029 break;
9030
9031 case 6700: hash_type = HASH_TYPE_SHA1;
9032 salt_type = SALT_TYPE_EMBEDDED;
9033 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9034 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9035 kern_type = KERN_TYPE_SHA1AIX;
9036 dgst_size = DGST_SIZE_4_5;
9037 parse_func = sha1aix_parse_hash;
9038 sort_by_digest = sort_by_digest_4_5;
9039 opti_type = OPTI_TYPE_ZERO_BYTE;
9040 dgst_pos0 = 0;
9041 dgst_pos1 = 1;
9042 dgst_pos2 = 2;
9043 dgst_pos3 = 3;
9044 break;
9045
9046 case 6800: hash_type = HASH_TYPE_AES;
9047 salt_type = SALT_TYPE_EMBEDDED;
9048 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9049 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9050 kern_type = KERN_TYPE_LASTPASS;
9051 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9052 parse_func = lastpass_parse_hash;
9053 sort_by_digest = sort_by_digest_4_8;
9054 opti_type = OPTI_TYPE_ZERO_BYTE;
9055 dgst_pos0 = 0;
9056 dgst_pos1 = 1;
9057 dgst_pos2 = 2;
9058 dgst_pos3 = 3;
9059 break;
9060
9061 case 6900: hash_type = HASH_TYPE_GOST;
9062 salt_type = SALT_TYPE_NONE;
9063 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9064 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9065 kern_type = KERN_TYPE_GOST;
9066 dgst_size = DGST_SIZE_4_8;
9067 parse_func = gost_parse_hash;
9068 sort_by_digest = sort_by_digest_4_8;
9069 opti_type = OPTI_TYPE_ZERO_BYTE;
9070 dgst_pos0 = 0;
9071 dgst_pos1 = 1;
9072 dgst_pos2 = 2;
9073 dgst_pos3 = 3;
9074 break;
9075
9076 case 7100: hash_type = HASH_TYPE_SHA512;
9077 salt_type = SALT_TYPE_EMBEDDED;
9078 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9079 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9080 kern_type = KERN_TYPE_PBKDF2_SHA512;
9081 dgst_size = DGST_SIZE_8_16;
9082 parse_func = sha512osx_parse_hash;
9083 sort_by_digest = sort_by_digest_8_16;
9084 opti_type = OPTI_TYPE_ZERO_BYTE
9085 | OPTI_TYPE_USES_BITS_64;
9086 dgst_pos0 = 0;
9087 dgst_pos1 = 1;
9088 dgst_pos2 = 2;
9089 dgst_pos3 = 3;
9090 break;
9091
9092 case 7200: hash_type = HASH_TYPE_SHA512;
9093 salt_type = SALT_TYPE_EMBEDDED;
9094 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9095 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9096 kern_type = KERN_TYPE_PBKDF2_SHA512;
9097 dgst_size = DGST_SIZE_8_16;
9098 parse_func = sha512grub_parse_hash;
9099 sort_by_digest = sort_by_digest_8_16;
9100 opti_type = OPTI_TYPE_ZERO_BYTE
9101 | OPTI_TYPE_USES_BITS_64;
9102 dgst_pos0 = 0;
9103 dgst_pos1 = 1;
9104 dgst_pos2 = 2;
9105 dgst_pos3 = 3;
9106 break;
9107
9108 case 7300: hash_type = HASH_TYPE_SHA1;
9109 salt_type = SALT_TYPE_EMBEDDED;
9110 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9111 opts_type = OPTS_TYPE_PT_GENERATE_BE
9112 | OPTS_TYPE_ST_ADD80
9113 | OPTS_TYPE_ST_ADDBITS15;
9114 kern_type = KERN_TYPE_RAKP;
9115 dgst_size = DGST_SIZE_4_5;
9116 parse_func = rakp_parse_hash;
9117 sort_by_digest = sort_by_digest_4_5;
9118 opti_type = OPTI_TYPE_ZERO_BYTE
9119 | OPTI_TYPE_NOT_ITERATED;
9120 dgst_pos0 = 3;
9121 dgst_pos1 = 4;
9122 dgst_pos2 = 2;
9123 dgst_pos3 = 1;
9124 break;
9125
9126 case 7400: hash_type = HASH_TYPE_SHA256;
9127 salt_type = SALT_TYPE_EMBEDDED;
9128 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9129 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9130 kern_type = KERN_TYPE_SHA256CRYPT;
9131 dgst_size = DGST_SIZE_4_8;
9132 parse_func = sha256crypt_parse_hash;
9133 sort_by_digest = sort_by_digest_4_8;
9134 opti_type = OPTI_TYPE_ZERO_BYTE;
9135 dgst_pos0 = 0;
9136 dgst_pos1 = 1;
9137 dgst_pos2 = 2;
9138 dgst_pos3 = 3;
9139 break;
9140
9141 case 7500: hash_type = HASH_TYPE_KRB5PA;
9142 salt_type = SALT_TYPE_EMBEDDED;
9143 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9144 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9145 kern_type = KERN_TYPE_KRB5PA;
9146 dgst_size = DGST_SIZE_4_4;
9147 parse_func = krb5pa_parse_hash;
9148 sort_by_digest = sort_by_digest_4_4;
9149 opti_type = OPTI_TYPE_ZERO_BYTE
9150 | OPTI_TYPE_NOT_ITERATED;
9151 dgst_pos0 = 0;
9152 dgst_pos1 = 1;
9153 dgst_pos2 = 2;
9154 dgst_pos3 = 3;
9155 break;
9156
9157 case 7600: hash_type = HASH_TYPE_SHA1;
9158 salt_type = SALT_TYPE_INTERN;
9159 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9160 opts_type = OPTS_TYPE_PT_GENERATE_BE
9161 | OPTS_TYPE_PT_ADD80
9162 | OPTS_TYPE_PT_ADDBITS15;
9163 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9164 dgst_size = DGST_SIZE_4_5;
9165 parse_func = redmine_parse_hash;
9166 sort_by_digest = sort_by_digest_4_5;
9167 opti_type = OPTI_TYPE_ZERO_BYTE
9168 | OPTI_TYPE_PRECOMPUTE_INIT
9169 | OPTI_TYPE_EARLY_SKIP
9170 | OPTI_TYPE_NOT_ITERATED
9171 | OPTI_TYPE_PREPENDED_SALT;
9172 dgst_pos0 = 3;
9173 dgst_pos1 = 4;
9174 dgst_pos2 = 2;
9175 dgst_pos3 = 1;
9176 break;
9177
9178 case 7700: hash_type = HASH_TYPE_SAPB;
9179 salt_type = SALT_TYPE_EMBEDDED;
9180 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9181 opts_type = OPTS_TYPE_PT_GENERATE_LE
9182 | OPTS_TYPE_PT_UPPER
9183 | OPTS_TYPE_ST_UPPER;
9184 kern_type = KERN_TYPE_SAPB;
9185 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9186 parse_func = sapb_parse_hash;
9187 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9188 opti_type = OPTI_TYPE_ZERO_BYTE
9189 | OPTI_TYPE_PRECOMPUTE_INIT
9190 | OPTI_TYPE_NOT_ITERATED;
9191 dgst_pos0 = 0;
9192 dgst_pos1 = 1;
9193 dgst_pos2 = 2;
9194 dgst_pos3 = 3;
9195 break;
9196
9197 case 7800: hash_type = HASH_TYPE_SAPG;
9198 salt_type = SALT_TYPE_EMBEDDED;
9199 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9200 opts_type = OPTS_TYPE_PT_GENERATE_BE
9201 | OPTS_TYPE_ST_ADD80
9202 | OPTS_TYPE_ST_UPPER;
9203 kern_type = KERN_TYPE_SAPG;
9204 dgst_size = DGST_SIZE_4_5;
9205 parse_func = sapg_parse_hash;
9206 sort_by_digest = sort_by_digest_4_5;
9207 opti_type = OPTI_TYPE_ZERO_BYTE
9208 | OPTI_TYPE_PRECOMPUTE_INIT
9209 | OPTI_TYPE_NOT_ITERATED;
9210 dgst_pos0 = 3;
9211 dgst_pos1 = 4;
9212 dgst_pos2 = 2;
9213 dgst_pos3 = 1;
9214 break;
9215
9216 case 7900: hash_type = HASH_TYPE_SHA512;
9217 salt_type = SALT_TYPE_EMBEDDED;
9218 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9219 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9220 kern_type = KERN_TYPE_DRUPAL7;
9221 dgst_size = DGST_SIZE_8_8;
9222 parse_func = drupal7_parse_hash;
9223 sort_by_digest = sort_by_digest_8_8;
9224 opti_type = OPTI_TYPE_ZERO_BYTE
9225 | OPTI_TYPE_USES_BITS_64;
9226 dgst_pos0 = 0;
9227 dgst_pos1 = 1;
9228 dgst_pos2 = 2;
9229 dgst_pos3 = 3;
9230 break;
9231
9232 case 8000: hash_type = HASH_TYPE_SHA256;
9233 salt_type = SALT_TYPE_EMBEDDED;
9234 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9235 opts_type = OPTS_TYPE_PT_GENERATE_BE
9236 | OPTS_TYPE_PT_UNICODE
9237 | OPTS_TYPE_ST_ADD80
9238 | OPTS_TYPE_ST_HEX;
9239 kern_type = KERN_TYPE_SYBASEASE;
9240 dgst_size = DGST_SIZE_4_8;
9241 parse_func = sybasease_parse_hash;
9242 sort_by_digest = sort_by_digest_4_8;
9243 opti_type = OPTI_TYPE_ZERO_BYTE
9244 | OPTI_TYPE_PRECOMPUTE_INIT
9245 | OPTI_TYPE_EARLY_SKIP
9246 | OPTI_TYPE_NOT_ITERATED
9247 | OPTI_TYPE_RAW_HASH;
9248 dgst_pos0 = 3;
9249 dgst_pos1 = 7;
9250 dgst_pos2 = 2;
9251 dgst_pos3 = 6;
9252 break;
9253
9254 case 8100: hash_type = HASH_TYPE_SHA1;
9255 salt_type = SALT_TYPE_EMBEDDED;
9256 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9257 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9258 kern_type = KERN_TYPE_NETSCALER;
9259 dgst_size = DGST_SIZE_4_5;
9260 parse_func = netscaler_parse_hash;
9261 sort_by_digest = sort_by_digest_4_5;
9262 opti_type = OPTI_TYPE_ZERO_BYTE
9263 | OPTI_TYPE_PRECOMPUTE_INIT
9264 | OPTI_TYPE_PRECOMPUTE_MERKLE
9265 | OPTI_TYPE_EARLY_SKIP
9266 | OPTI_TYPE_NOT_ITERATED
9267 | OPTI_TYPE_PREPENDED_SALT
9268 | OPTI_TYPE_RAW_HASH;
9269 dgst_pos0 = 3;
9270 dgst_pos1 = 4;
9271 dgst_pos2 = 2;
9272 dgst_pos3 = 1;
9273 break;
9274
9275 case 8200: hash_type = HASH_TYPE_SHA256;
9276 salt_type = SALT_TYPE_EMBEDDED;
9277 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9278 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9279 kern_type = KERN_TYPE_CLOUDKEY;
9280 dgst_size = DGST_SIZE_4_8;
9281 parse_func = cloudkey_parse_hash;
9282 sort_by_digest = sort_by_digest_4_8;
9283 opti_type = OPTI_TYPE_ZERO_BYTE;
9284 dgst_pos0 = 0;
9285 dgst_pos1 = 1;
9286 dgst_pos2 = 2;
9287 dgst_pos3 = 3;
9288 break;
9289
9290 case 8300: hash_type = HASH_TYPE_SHA1;
9291 salt_type = SALT_TYPE_EMBEDDED;
9292 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9293 opts_type = OPTS_TYPE_PT_GENERATE_LE
9294 | OPTS_TYPE_ST_HEX
9295 | OPTS_TYPE_ST_ADD80;
9296 kern_type = KERN_TYPE_NSEC3;
9297 dgst_size = DGST_SIZE_4_5;
9298 parse_func = nsec3_parse_hash;
9299 sort_by_digest = sort_by_digest_4_5;
9300 opti_type = OPTI_TYPE_ZERO_BYTE;
9301 dgst_pos0 = 3;
9302 dgst_pos1 = 4;
9303 dgst_pos2 = 2;
9304 dgst_pos3 = 1;
9305 break;
9306
9307 case 8400: hash_type = HASH_TYPE_SHA1;
9308 salt_type = SALT_TYPE_INTERN;
9309 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9310 opts_type = OPTS_TYPE_PT_GENERATE_BE
9311 | OPTS_TYPE_PT_ADD80
9312 | OPTS_TYPE_PT_ADDBITS15;
9313 kern_type = KERN_TYPE_WBB3;
9314 dgst_size = DGST_SIZE_4_5;
9315 parse_func = wbb3_parse_hash;
9316 sort_by_digest = sort_by_digest_4_5;
9317 opti_type = OPTI_TYPE_ZERO_BYTE
9318 | OPTI_TYPE_PRECOMPUTE_INIT
9319 | OPTI_TYPE_NOT_ITERATED;
9320 dgst_pos0 = 3;
9321 dgst_pos1 = 4;
9322 dgst_pos2 = 2;
9323 dgst_pos3 = 1;
9324 break;
9325
9326 case 8500: hash_type = HASH_TYPE_DESRACF;
9327 salt_type = SALT_TYPE_EMBEDDED;
9328 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9329 opts_type = OPTS_TYPE_PT_GENERATE_LE
9330 | OPTS_TYPE_ST_UPPER;
9331 kern_type = KERN_TYPE_RACF;
9332 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9333 parse_func = racf_parse_hash;
9334 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9335 opti_type = OPTI_TYPE_ZERO_BYTE
9336 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9337 dgst_pos0 = 0;
9338 dgst_pos1 = 1;
9339 dgst_pos2 = 2;
9340 dgst_pos3 = 3;
9341 break;
9342
9343 case 8600: hash_type = HASH_TYPE_LOTUS5;
9344 salt_type = SALT_TYPE_NONE;
9345 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9346 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9347 kern_type = KERN_TYPE_LOTUS5;
9348 dgst_size = DGST_SIZE_4_4;
9349 parse_func = lotus5_parse_hash;
9350 sort_by_digest = sort_by_digest_4_4;
9351 opti_type = OPTI_TYPE_EARLY_SKIP
9352 | OPTI_TYPE_NOT_ITERATED
9353 | OPTI_TYPE_NOT_SALTED
9354 | OPTI_TYPE_RAW_HASH;
9355 dgst_pos0 = 0;
9356 dgst_pos1 = 1;
9357 dgst_pos2 = 2;
9358 dgst_pos3 = 3;
9359 break;
9360
9361 case 8700: hash_type = HASH_TYPE_LOTUS6;
9362 salt_type = SALT_TYPE_EMBEDDED;
9363 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9364 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9365 kern_type = KERN_TYPE_LOTUS6;
9366 dgst_size = DGST_SIZE_4_4;
9367 parse_func = lotus6_parse_hash;
9368 sort_by_digest = sort_by_digest_4_4;
9369 opti_type = OPTI_TYPE_EARLY_SKIP
9370 | OPTI_TYPE_NOT_ITERATED
9371 | OPTI_TYPE_RAW_HASH;
9372 dgst_pos0 = 0;
9373 dgst_pos1 = 1;
9374 dgst_pos2 = 2;
9375 dgst_pos3 = 3;
9376 break;
9377
9378 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9379 salt_type = SALT_TYPE_EMBEDDED;
9380 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9381 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9382 kern_type = KERN_TYPE_ANDROIDFDE;
9383 dgst_size = DGST_SIZE_4_4;
9384 parse_func = androidfde_parse_hash;
9385 sort_by_digest = sort_by_digest_4_4;
9386 opti_type = OPTI_TYPE_ZERO_BYTE;
9387 dgst_pos0 = 0;
9388 dgst_pos1 = 1;
9389 dgst_pos2 = 2;
9390 dgst_pos3 = 3;
9391 break;
9392
9393 case 8900: hash_type = HASH_TYPE_SCRYPT;
9394 salt_type = SALT_TYPE_EMBEDDED;
9395 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9396 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9397 kern_type = KERN_TYPE_SCRYPT;
9398 dgst_size = DGST_SIZE_4_8;
9399 parse_func = scrypt_parse_hash;
9400 sort_by_digest = sort_by_digest_4_8;
9401 opti_type = OPTI_TYPE_ZERO_BYTE;
9402 dgst_pos0 = 0;
9403 dgst_pos1 = 1;
9404 dgst_pos2 = 2;
9405 dgst_pos3 = 3;
9406 break;
9407
9408 case 9000: hash_type = HASH_TYPE_SHA1;
9409 salt_type = SALT_TYPE_EMBEDDED;
9410 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9411 opts_type = OPTS_TYPE_PT_GENERATE_LE
9412 | OPTS_TYPE_ST_GENERATE_LE;
9413 kern_type = KERN_TYPE_PSAFE2;
9414 dgst_size = DGST_SIZE_4_5;
9415 parse_func = psafe2_parse_hash;
9416 sort_by_digest = sort_by_digest_4_5;
9417 opti_type = OPTI_TYPE_ZERO_BYTE;
9418 dgst_pos0 = 0;
9419 dgst_pos1 = 1;
9420 dgst_pos2 = 2;
9421 dgst_pos3 = 3;
9422 break;
9423
9424 case 9100: hash_type = HASH_TYPE_LOTUS8;
9425 salt_type = SALT_TYPE_EMBEDDED;
9426 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9427 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9428 kern_type = KERN_TYPE_LOTUS8;
9429 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9430 parse_func = lotus8_parse_hash;
9431 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9432 opti_type = OPTI_TYPE_ZERO_BYTE;
9433 dgst_pos0 = 0;
9434 dgst_pos1 = 1;
9435 dgst_pos2 = 2;
9436 dgst_pos3 = 3;
9437 break;
9438
9439 case 9200: hash_type = HASH_TYPE_SHA256;
9440 salt_type = SALT_TYPE_EMBEDDED;
9441 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9442 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9443 kern_type = KERN_TYPE_PBKDF2_SHA256;
9444 dgst_size = DGST_SIZE_4_32;
9445 parse_func = cisco8_parse_hash;
9446 sort_by_digest = sort_by_digest_4_32;
9447 opti_type = OPTI_TYPE_ZERO_BYTE;
9448 dgst_pos0 = 0;
9449 dgst_pos1 = 1;
9450 dgst_pos2 = 2;
9451 dgst_pos3 = 3;
9452 break;
9453
9454 case 9300: hash_type = HASH_TYPE_SCRYPT;
9455 salt_type = SALT_TYPE_EMBEDDED;
9456 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9457 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9458 kern_type = KERN_TYPE_SCRYPT;
9459 dgst_size = DGST_SIZE_4_8;
9460 parse_func = cisco9_parse_hash;
9461 sort_by_digest = sort_by_digest_4_8;
9462 opti_type = OPTI_TYPE_ZERO_BYTE;
9463 dgst_pos0 = 0;
9464 dgst_pos1 = 1;
9465 dgst_pos2 = 2;
9466 dgst_pos3 = 3;
9467 break;
9468
9469 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9470 salt_type = SALT_TYPE_EMBEDDED;
9471 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9472 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9473 kern_type = KERN_TYPE_OFFICE2007;
9474 dgst_size = DGST_SIZE_4_4;
9475 parse_func = office2007_parse_hash;
9476 sort_by_digest = sort_by_digest_4_4;
9477 opti_type = OPTI_TYPE_ZERO_BYTE;
9478 dgst_pos0 = 0;
9479 dgst_pos1 = 1;
9480 dgst_pos2 = 2;
9481 dgst_pos3 = 3;
9482 break;
9483
9484 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9485 salt_type = SALT_TYPE_EMBEDDED;
9486 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9487 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9488 kern_type = KERN_TYPE_OFFICE2010;
9489 dgst_size = DGST_SIZE_4_4;
9490 parse_func = office2010_parse_hash;
9491 sort_by_digest = sort_by_digest_4_4;
9492 opti_type = OPTI_TYPE_ZERO_BYTE;
9493 dgst_pos0 = 0;
9494 dgst_pos1 = 1;
9495 dgst_pos2 = 2;
9496 dgst_pos3 = 3;
9497 break;
9498
9499 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9500 salt_type = SALT_TYPE_EMBEDDED;
9501 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9502 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9503 kern_type = KERN_TYPE_OFFICE2013;
9504 dgst_size = DGST_SIZE_4_4;
9505 parse_func = office2013_parse_hash;
9506 sort_by_digest = sort_by_digest_4_4;
9507 opti_type = OPTI_TYPE_ZERO_BYTE;
9508 dgst_pos0 = 0;
9509 dgst_pos1 = 1;
9510 dgst_pos2 = 2;
9511 dgst_pos3 = 3;
9512 break;
9513
9514 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9515 salt_type = SALT_TYPE_EMBEDDED;
9516 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9517 opts_type = OPTS_TYPE_PT_GENERATE_LE
9518 | OPTS_TYPE_PT_ADD80
9519 | OPTS_TYPE_PT_UNICODE;
9520 kern_type = KERN_TYPE_OLDOFFICE01;
9521 dgst_size = DGST_SIZE_4_4;
9522 parse_func = oldoffice01_parse_hash;
9523 sort_by_digest = sort_by_digest_4_4;
9524 opti_type = OPTI_TYPE_ZERO_BYTE
9525 | OPTI_TYPE_PRECOMPUTE_INIT
9526 | OPTI_TYPE_NOT_ITERATED;
9527 dgst_pos0 = 0;
9528 dgst_pos1 = 1;
9529 dgst_pos2 = 2;
9530 dgst_pos3 = 3;
9531 break;
9532
9533 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9534 salt_type = SALT_TYPE_EMBEDDED;
9535 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9536 opts_type = OPTS_TYPE_PT_GENERATE_LE
9537 | OPTS_TYPE_PT_ADD80;
9538 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9539 dgst_size = DGST_SIZE_4_4;
9540 parse_func = oldoffice01cm1_parse_hash;
9541 sort_by_digest = sort_by_digest_4_4;
9542 opti_type = OPTI_TYPE_ZERO_BYTE
9543 | OPTI_TYPE_PRECOMPUTE_INIT
9544 | OPTI_TYPE_NOT_ITERATED;
9545 dgst_pos0 = 0;
9546 dgst_pos1 = 1;
9547 dgst_pos2 = 2;
9548 dgst_pos3 = 3;
9549 break;
9550
9551 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9552 salt_type = SALT_TYPE_EMBEDDED;
9553 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9554 opts_type = OPTS_TYPE_PT_GENERATE_LE
9555 | OPTS_TYPE_PT_ADD80
9556 | OPTS_TYPE_PT_UNICODE
9557 | OPTS_TYPE_PT_NEVERCRACK;
9558 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9559 dgst_size = DGST_SIZE_4_4;
9560 parse_func = oldoffice01cm2_parse_hash;
9561 sort_by_digest = sort_by_digest_4_4;
9562 opti_type = OPTI_TYPE_ZERO_BYTE
9563 | OPTI_TYPE_PRECOMPUTE_INIT
9564 | OPTI_TYPE_NOT_ITERATED;
9565 dgst_pos0 = 0;
9566 dgst_pos1 = 1;
9567 dgst_pos2 = 2;
9568 dgst_pos3 = 3;
9569 break;
9570
9571 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9572 salt_type = SALT_TYPE_EMBEDDED;
9573 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9574 opts_type = OPTS_TYPE_PT_GENERATE_BE
9575 | OPTS_TYPE_PT_ADD80
9576 | OPTS_TYPE_PT_UNICODE;
9577 kern_type = KERN_TYPE_OLDOFFICE34;
9578 dgst_size = DGST_SIZE_4_4;
9579 parse_func = oldoffice34_parse_hash;
9580 sort_by_digest = sort_by_digest_4_4;
9581 opti_type = OPTI_TYPE_ZERO_BYTE
9582 | OPTI_TYPE_PRECOMPUTE_INIT
9583 | OPTI_TYPE_NOT_ITERATED;
9584 dgst_pos0 = 0;
9585 dgst_pos1 = 1;
9586 dgst_pos2 = 2;
9587 dgst_pos3 = 3;
9588 break;
9589
9590 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9591 salt_type = SALT_TYPE_EMBEDDED;
9592 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9593 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9594 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9595 dgst_size = DGST_SIZE_4_4;
9596 parse_func = oldoffice34cm1_parse_hash;
9597 sort_by_digest = sort_by_digest_4_4;
9598 opti_type = OPTI_TYPE_ZERO_BYTE
9599 | OPTI_TYPE_PRECOMPUTE_INIT
9600 | OPTI_TYPE_NOT_ITERATED;
9601 dgst_pos0 = 0;
9602 dgst_pos1 = 1;
9603 dgst_pos2 = 2;
9604 dgst_pos3 = 3;
9605 break;
9606
9607 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9608 salt_type = SALT_TYPE_EMBEDDED;
9609 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9610 opts_type = OPTS_TYPE_PT_GENERATE_BE
9611 | OPTS_TYPE_PT_ADD80
9612 | OPTS_TYPE_PT_UNICODE
9613 | OPTS_TYPE_PT_NEVERCRACK;
9614 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9615 dgst_size = DGST_SIZE_4_4;
9616 parse_func = oldoffice34cm2_parse_hash;
9617 sort_by_digest = sort_by_digest_4_4;
9618 opti_type = OPTI_TYPE_ZERO_BYTE
9619 | OPTI_TYPE_PRECOMPUTE_INIT
9620 | OPTI_TYPE_NOT_ITERATED;
9621 dgst_pos0 = 0;
9622 dgst_pos1 = 1;
9623 dgst_pos2 = 2;
9624 dgst_pos3 = 3;
9625 break;
9626
9627 case 9900: hash_type = HASH_TYPE_MD5;
9628 salt_type = SALT_TYPE_NONE;
9629 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9630 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9631 kern_type = KERN_TYPE_RADMIN2;
9632 dgst_size = DGST_SIZE_4_4;
9633 parse_func = radmin2_parse_hash;
9634 sort_by_digest = sort_by_digest_4_4;
9635 opti_type = OPTI_TYPE_ZERO_BYTE
9636 | OPTI_TYPE_PRECOMPUTE_INIT
9637 | OPTI_TYPE_EARLY_SKIP
9638 | OPTI_TYPE_NOT_ITERATED
9639 | OPTI_TYPE_NOT_SALTED;
9640 dgst_pos0 = 0;
9641 dgst_pos1 = 3;
9642 dgst_pos2 = 2;
9643 dgst_pos3 = 1;
9644 break;
9645
9646 case 10000: hash_type = HASH_TYPE_SHA256;
9647 salt_type = SALT_TYPE_EMBEDDED;
9648 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9649 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9650 kern_type = KERN_TYPE_PBKDF2_SHA256;
9651 dgst_size = DGST_SIZE_4_32;
9652 parse_func = djangopbkdf2_parse_hash;
9653 sort_by_digest = sort_by_digest_4_32;
9654 opti_type = OPTI_TYPE_ZERO_BYTE;
9655 dgst_pos0 = 0;
9656 dgst_pos1 = 1;
9657 dgst_pos2 = 2;
9658 dgst_pos3 = 3;
9659 break;
9660
9661 case 10100: hash_type = HASH_TYPE_SIPHASH;
9662 salt_type = SALT_TYPE_EMBEDDED;
9663 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9664 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9665 kern_type = KERN_TYPE_SIPHASH;
9666 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9667 parse_func = siphash_parse_hash;
9668 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9669 opti_type = OPTI_TYPE_ZERO_BYTE
9670 | OPTI_TYPE_NOT_ITERATED
9671 | OPTI_TYPE_RAW_HASH;
9672 dgst_pos0 = 0;
9673 dgst_pos1 = 1;
9674 dgst_pos2 = 2;
9675 dgst_pos3 = 3;
9676 break;
9677
9678 case 10200: hash_type = HASH_TYPE_MD5;
9679 salt_type = SALT_TYPE_EMBEDDED;
9680 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9681 opts_type = OPTS_TYPE_PT_GENERATE_LE
9682 | OPTS_TYPE_ST_ADD80
9683 | OPTS_TYPE_ST_ADDBITS14;
9684 kern_type = KERN_TYPE_HMACMD5_PW;
9685 dgst_size = DGST_SIZE_4_4;
9686 parse_func = crammd5_parse_hash;
9687 sort_by_digest = sort_by_digest_4_4;
9688 opti_type = OPTI_TYPE_ZERO_BYTE
9689 | OPTI_TYPE_NOT_ITERATED;
9690 dgst_pos0 = 0;
9691 dgst_pos1 = 3;
9692 dgst_pos2 = 2;
9693 dgst_pos3 = 1;
9694 break;
9695
9696 case 10300: hash_type = HASH_TYPE_SHA1;
9697 salt_type = SALT_TYPE_EMBEDDED;
9698 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9699 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9700 kern_type = KERN_TYPE_SAPH_SHA1;
9701 dgst_size = DGST_SIZE_4_5;
9702 parse_func = saph_sha1_parse_hash;
9703 sort_by_digest = sort_by_digest_4_5;
9704 opti_type = OPTI_TYPE_ZERO_BYTE;
9705 dgst_pos0 = 0;
9706 dgst_pos1 = 1;
9707 dgst_pos2 = 2;
9708 dgst_pos3 = 3;
9709 break;
9710
9711 case 10400: hash_type = HASH_TYPE_PDFU16;
9712 salt_type = SALT_TYPE_EMBEDDED;
9713 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9714 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9715 kern_type = KERN_TYPE_PDF11;
9716 dgst_size = DGST_SIZE_4_4;
9717 parse_func = pdf11_parse_hash;
9718 sort_by_digest = sort_by_digest_4_4;
9719 opti_type = OPTI_TYPE_ZERO_BYTE
9720 | OPTI_TYPE_NOT_ITERATED;
9721 dgst_pos0 = 0;
9722 dgst_pos1 = 1;
9723 dgst_pos2 = 2;
9724 dgst_pos3 = 3;
9725 break;
9726
9727 case 10410: hash_type = HASH_TYPE_PDFU16;
9728 salt_type = SALT_TYPE_EMBEDDED;
9729 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9730 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9731 kern_type = KERN_TYPE_PDF11CM1;
9732 dgst_size = DGST_SIZE_4_4;
9733 parse_func = pdf11cm1_parse_hash;
9734 sort_by_digest = sort_by_digest_4_4;
9735 opti_type = OPTI_TYPE_ZERO_BYTE
9736 | OPTI_TYPE_NOT_ITERATED;
9737 dgst_pos0 = 0;
9738 dgst_pos1 = 1;
9739 dgst_pos2 = 2;
9740 dgst_pos3 = 3;
9741 break;
9742
9743 case 10420: hash_type = HASH_TYPE_PDFU16;
9744 salt_type = SALT_TYPE_EMBEDDED;
9745 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9746 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9747 kern_type = KERN_TYPE_PDF11CM2;
9748 dgst_size = DGST_SIZE_4_4;
9749 parse_func = pdf11cm2_parse_hash;
9750 sort_by_digest = sort_by_digest_4_4;
9751 opti_type = OPTI_TYPE_ZERO_BYTE
9752 | OPTI_TYPE_NOT_ITERATED;
9753 dgst_pos0 = 0;
9754 dgst_pos1 = 1;
9755 dgst_pos2 = 2;
9756 dgst_pos3 = 3;
9757 break;
9758
9759 case 10500: hash_type = HASH_TYPE_PDFU16;
9760 salt_type = SALT_TYPE_EMBEDDED;
9761 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9762 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9763 kern_type = KERN_TYPE_PDF14;
9764 dgst_size = DGST_SIZE_4_4;
9765 parse_func = pdf14_parse_hash;
9766 sort_by_digest = sort_by_digest_4_4;
9767 opti_type = OPTI_TYPE_ZERO_BYTE
9768 | OPTI_TYPE_NOT_ITERATED;
9769 dgst_pos0 = 0;
9770 dgst_pos1 = 1;
9771 dgst_pos2 = 2;
9772 dgst_pos3 = 3;
9773 break;
9774
9775 case 10600: hash_type = HASH_TYPE_SHA256;
9776 salt_type = SALT_TYPE_EMBEDDED;
9777 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9778 opts_type = OPTS_TYPE_PT_GENERATE_BE
9779 | OPTS_TYPE_ST_ADD80
9780 | OPTS_TYPE_ST_ADDBITS15
9781 | OPTS_TYPE_HASH_COPY;
9782 kern_type = KERN_TYPE_SHA256_PWSLT;
9783 dgst_size = DGST_SIZE_4_8;
9784 parse_func = pdf17l3_parse_hash;
9785 sort_by_digest = sort_by_digest_4_8;
9786 opti_type = OPTI_TYPE_ZERO_BYTE
9787 | OPTI_TYPE_PRECOMPUTE_INIT
9788 | OPTI_TYPE_PRECOMPUTE_MERKLE
9789 | OPTI_TYPE_EARLY_SKIP
9790 | OPTI_TYPE_NOT_ITERATED
9791 | OPTI_TYPE_APPENDED_SALT
9792 | OPTI_TYPE_RAW_HASH;
9793 dgst_pos0 = 3;
9794 dgst_pos1 = 7;
9795 dgst_pos2 = 2;
9796 dgst_pos3 = 6;
9797 break;
9798
9799 case 10700: hash_type = HASH_TYPE_PDFU32;
9800 salt_type = SALT_TYPE_EMBEDDED;
9801 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9802 opts_type = OPTS_TYPE_PT_GENERATE_LE
9803 | OPTS_TYPE_HASH_COPY;
9804 kern_type = KERN_TYPE_PDF17L8;
9805 dgst_size = DGST_SIZE_4_8;
9806 parse_func = pdf17l8_parse_hash;
9807 sort_by_digest = sort_by_digest_4_8;
9808 opti_type = OPTI_TYPE_ZERO_BYTE
9809 | OPTI_TYPE_NOT_ITERATED;
9810 dgst_pos0 = 0;
9811 dgst_pos1 = 1;
9812 dgst_pos2 = 2;
9813 dgst_pos3 = 3;
9814 break;
9815
9816 case 10800: hash_type = HASH_TYPE_SHA384;
9817 salt_type = SALT_TYPE_NONE;
9818 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9819 opts_type = OPTS_TYPE_PT_GENERATE_BE
9820 | OPTS_TYPE_PT_ADD80
9821 | OPTS_TYPE_PT_ADDBITS15;
9822 kern_type = KERN_TYPE_SHA384;
9823 dgst_size = DGST_SIZE_8_8;
9824 parse_func = sha384_parse_hash;
9825 sort_by_digest = sort_by_digest_8_8;
9826 opti_type = OPTI_TYPE_ZERO_BYTE
9827 | OPTI_TYPE_PRECOMPUTE_INIT
9828 | OPTI_TYPE_PRECOMPUTE_MERKLE
9829 | OPTI_TYPE_EARLY_SKIP
9830 | OPTI_TYPE_NOT_ITERATED
9831 | OPTI_TYPE_NOT_SALTED
9832 | OPTI_TYPE_USES_BITS_64
9833 | OPTI_TYPE_RAW_HASH;
9834 dgst_pos0 = 6;
9835 dgst_pos1 = 7;
9836 dgst_pos2 = 4;
9837 dgst_pos3 = 5;
9838 break;
9839
9840 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9841 salt_type = SALT_TYPE_EMBEDDED;
9842 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9843 opts_type = OPTS_TYPE_PT_GENERATE_LE
9844 | OPTS_TYPE_ST_BASE64
9845 | OPTS_TYPE_HASH_COPY;
9846 kern_type = KERN_TYPE_PBKDF2_SHA256;
9847 dgst_size = DGST_SIZE_4_32;
9848 parse_func = pbkdf2_sha256_parse_hash;
9849 sort_by_digest = sort_by_digest_4_32;
9850 opti_type = OPTI_TYPE_ZERO_BYTE;
9851 dgst_pos0 = 0;
9852 dgst_pos1 = 1;
9853 dgst_pos2 = 2;
9854 dgst_pos3 = 3;
9855 break;
9856
9857 case 11000: hash_type = HASH_TYPE_MD5;
9858 salt_type = SALT_TYPE_INTERN;
9859 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9860 opts_type = OPTS_TYPE_PT_GENERATE_LE
9861 | OPTS_TYPE_PT_ADD80;
9862 kern_type = KERN_TYPE_PRESTASHOP;
9863 dgst_size = DGST_SIZE_4_4;
9864 parse_func = prestashop_parse_hash;
9865 sort_by_digest = sort_by_digest_4_4;
9866 opti_type = OPTI_TYPE_ZERO_BYTE
9867 | OPTI_TYPE_PRECOMPUTE_INIT
9868 | OPTI_TYPE_NOT_ITERATED
9869 | OPTI_TYPE_PREPENDED_SALT;
9870 dgst_pos0 = 0;
9871 dgst_pos1 = 3;
9872 dgst_pos2 = 2;
9873 dgst_pos3 = 1;
9874 break;
9875
9876 case 11100: hash_type = HASH_TYPE_MD5;
9877 salt_type = SALT_TYPE_EMBEDDED;
9878 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9879 opts_type = OPTS_TYPE_PT_GENERATE_LE
9880 | OPTS_TYPE_ST_ADD80;
9881 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9882 dgst_size = DGST_SIZE_4_4;
9883 parse_func = postgresql_auth_parse_hash;
9884 sort_by_digest = sort_by_digest_4_4;
9885 opti_type = OPTI_TYPE_ZERO_BYTE
9886 | OPTI_TYPE_PRECOMPUTE_INIT
9887 | OPTI_TYPE_PRECOMPUTE_MERKLE
9888 | OPTI_TYPE_EARLY_SKIP;
9889 dgst_pos0 = 0;
9890 dgst_pos1 = 3;
9891 dgst_pos2 = 2;
9892 dgst_pos3 = 1;
9893 break;
9894
9895 case 11200: hash_type = HASH_TYPE_SHA1;
9896 salt_type = SALT_TYPE_EMBEDDED;
9897 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9898 opts_type = OPTS_TYPE_PT_GENERATE_BE
9899 | OPTS_TYPE_PT_ADD80
9900 | OPTS_TYPE_ST_HEX;
9901 kern_type = KERN_TYPE_MYSQL_AUTH;
9902 dgst_size = DGST_SIZE_4_5;
9903 parse_func = mysql_auth_parse_hash;
9904 sort_by_digest = sort_by_digest_4_5;
9905 opti_type = OPTI_TYPE_ZERO_BYTE
9906 | OPTI_TYPE_EARLY_SKIP;
9907 dgst_pos0 = 3;
9908 dgst_pos1 = 4;
9909 dgst_pos2 = 2;
9910 dgst_pos3 = 1;
9911 break;
9912
9913 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9914 salt_type = SALT_TYPE_EMBEDDED;
9915 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9916 opts_type = OPTS_TYPE_PT_GENERATE_LE
9917 | OPTS_TYPE_ST_HEX
9918 | OPTS_TYPE_ST_ADD80;
9919 kern_type = KERN_TYPE_BITCOIN_WALLET;
9920 dgst_size = DGST_SIZE_4_4;
9921 parse_func = bitcoin_wallet_parse_hash;
9922 sort_by_digest = sort_by_digest_4_4;
9923 opti_type = OPTI_TYPE_ZERO_BYTE;
9924 dgst_pos0 = 0;
9925 dgst_pos1 = 1;
9926 dgst_pos2 = 2;
9927 dgst_pos3 = 3;
9928 break;
9929
9930 case 11400: hash_type = HASH_TYPE_MD5;
9931 salt_type = SALT_TYPE_EMBEDDED;
9932 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9933 opts_type = OPTS_TYPE_PT_GENERATE_LE
9934 | OPTS_TYPE_PT_ADD80
9935 | OPTS_TYPE_HASH_COPY;
9936 kern_type = KERN_TYPE_SIP_AUTH;
9937 dgst_size = DGST_SIZE_4_4;
9938 parse_func = sip_auth_parse_hash;
9939 sort_by_digest = sort_by_digest_4_4;
9940 opti_type = OPTI_TYPE_ZERO_BYTE;
9941 dgst_pos0 = 0;
9942 dgst_pos1 = 3;
9943 dgst_pos2 = 2;
9944 dgst_pos3 = 1;
9945 break;
9946
9947 case 11500: hash_type = HASH_TYPE_CRC32;
9948 salt_type = SALT_TYPE_INTERN;
9949 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9950 opts_type = OPTS_TYPE_PT_GENERATE_LE
9951 | OPTS_TYPE_ST_GENERATE_LE
9952 | OPTS_TYPE_ST_HEX;
9953 kern_type = KERN_TYPE_CRC32;
9954 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9955 parse_func = crc32_parse_hash;
9956 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9957 opti_type = OPTI_TYPE_ZERO_BYTE;
9958 dgst_pos0 = 0;
9959 dgst_pos1 = 1;
9960 dgst_pos2 = 2;
9961 dgst_pos3 = 3;
9962 break;
9963
9964 case 11600: hash_type = HASH_TYPE_AES;
9965 salt_type = SALT_TYPE_EMBEDDED;
9966 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9967 opts_type = OPTS_TYPE_PT_GENERATE_LE
9968 | OPTS_TYPE_PT_NEVERCRACK;
9969 kern_type = KERN_TYPE_SEVEN_ZIP;
9970 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9971 parse_func = seven_zip_parse_hash;
9972 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9973 opti_type = OPTI_TYPE_ZERO_BYTE;
9974 dgst_pos0 = 0;
9975 dgst_pos1 = 1;
9976 dgst_pos2 = 2;
9977 dgst_pos3 = 3;
9978 break;
9979
9980 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9981 salt_type = SALT_TYPE_NONE;
9982 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9983 opts_type = OPTS_TYPE_PT_GENERATE_LE
9984 | OPTS_TYPE_PT_ADD01;
9985 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9986 dgst_size = DGST_SIZE_4_8;
9987 parse_func = gost2012sbog_256_parse_hash;
9988 sort_by_digest = sort_by_digest_4_8;
9989 opti_type = OPTI_TYPE_ZERO_BYTE;
9990 dgst_pos0 = 0;
9991 dgst_pos1 = 1;
9992 dgst_pos2 = 2;
9993 dgst_pos3 = 3;
9994 break;
9995
9996 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
9997 salt_type = SALT_TYPE_NONE;
9998 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9999 opts_type = OPTS_TYPE_PT_GENERATE_LE
10000 | OPTS_TYPE_PT_ADD01;
10001 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10002 dgst_size = DGST_SIZE_4_16;
10003 parse_func = gost2012sbog_512_parse_hash;
10004 sort_by_digest = sort_by_digest_4_16;
10005 opti_type = OPTI_TYPE_ZERO_BYTE;
10006 dgst_pos0 = 0;
10007 dgst_pos1 = 1;
10008 dgst_pos2 = 2;
10009 dgst_pos3 = 3;
10010 break;
10011
10012 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10013 salt_type = SALT_TYPE_EMBEDDED;
10014 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10015 opts_type = OPTS_TYPE_PT_GENERATE_LE
10016 | OPTS_TYPE_ST_BASE64
10017 | OPTS_TYPE_HASH_COPY;
10018 kern_type = KERN_TYPE_PBKDF2_MD5;
10019 dgst_size = DGST_SIZE_4_32;
10020 parse_func = pbkdf2_md5_parse_hash;
10021 sort_by_digest = sort_by_digest_4_32;
10022 opti_type = OPTI_TYPE_ZERO_BYTE;
10023 dgst_pos0 = 0;
10024 dgst_pos1 = 1;
10025 dgst_pos2 = 2;
10026 dgst_pos3 = 3;
10027 break;
10028
10029 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10030 salt_type = SALT_TYPE_EMBEDDED;
10031 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10032 opts_type = OPTS_TYPE_PT_GENERATE_LE
10033 | OPTS_TYPE_ST_BASE64
10034 | OPTS_TYPE_HASH_COPY;
10035 kern_type = KERN_TYPE_PBKDF2_SHA1;
10036 dgst_size = DGST_SIZE_4_32;
10037 parse_func = pbkdf2_sha1_parse_hash;
10038 sort_by_digest = sort_by_digest_4_32;
10039 opti_type = OPTI_TYPE_ZERO_BYTE;
10040 dgst_pos0 = 0;
10041 dgst_pos1 = 1;
10042 dgst_pos2 = 2;
10043 dgst_pos3 = 3;
10044 break;
10045
10046 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10047 salt_type = SALT_TYPE_EMBEDDED;
10048 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10049 opts_type = OPTS_TYPE_PT_GENERATE_LE
10050 | OPTS_TYPE_ST_BASE64
10051 | OPTS_TYPE_HASH_COPY;
10052 kern_type = KERN_TYPE_PBKDF2_SHA512;
10053 dgst_size = DGST_SIZE_8_16;
10054 parse_func = pbkdf2_sha512_parse_hash;
10055 sort_by_digest = sort_by_digest_8_16;
10056 opti_type = OPTI_TYPE_ZERO_BYTE
10057 | OPTI_TYPE_USES_BITS_64;
10058 dgst_pos0 = 0;
10059 dgst_pos1 = 1;
10060 dgst_pos2 = 2;
10061 dgst_pos3 = 3;
10062 break;
10063
10064 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10065 salt_type = SALT_TYPE_EMBEDDED;
10066 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10067 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10068 kern_type = KERN_TYPE_ECRYPTFS;
10069 dgst_size = DGST_SIZE_8_8;
10070 parse_func = ecryptfs_parse_hash;
10071 sort_by_digest = sort_by_digest_8_8;
10072 opti_type = OPTI_TYPE_ZERO_BYTE
10073 | OPTI_TYPE_USES_BITS_64;
10074 dgst_pos0 = 0;
10075 dgst_pos1 = 1;
10076 dgst_pos2 = 2;
10077 dgst_pos3 = 3;
10078 break;
10079
10080 case 12300: hash_type = HASH_TYPE_ORACLET;
10081 salt_type = SALT_TYPE_EMBEDDED;
10082 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10083 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10084 kern_type = KERN_TYPE_ORACLET;
10085 dgst_size = DGST_SIZE_8_16;
10086 parse_func = oraclet_parse_hash;
10087 sort_by_digest = sort_by_digest_8_16;
10088 opti_type = OPTI_TYPE_ZERO_BYTE
10089 | OPTI_TYPE_USES_BITS_64;
10090 dgst_pos0 = 0;
10091 dgst_pos1 = 1;
10092 dgst_pos2 = 2;
10093 dgst_pos3 = 3;
10094 break;
10095
10096 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10097 salt_type = SALT_TYPE_EMBEDDED;
10098 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10099 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10100 kern_type = KERN_TYPE_BSDICRYPT;
10101 dgst_size = DGST_SIZE_4_4;
10102 parse_func = bsdicrypt_parse_hash;
10103 sort_by_digest = sort_by_digest_4_4;
10104 opti_type = OPTI_TYPE_ZERO_BYTE
10105 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10106 dgst_pos0 = 0;
10107 dgst_pos1 = 1;
10108 dgst_pos2 = 2;
10109 dgst_pos3 = 3;
10110 break;
10111
10112 case 12500: hash_type = HASH_TYPE_RAR3HP;
10113 salt_type = SALT_TYPE_EMBEDDED;
10114 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10115 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10116 kern_type = KERN_TYPE_RAR3;
10117 dgst_size = DGST_SIZE_4_4;
10118 parse_func = rar3hp_parse_hash;
10119 sort_by_digest = sort_by_digest_4_4;
10120 opti_type = OPTI_TYPE_ZERO_BYTE;
10121 dgst_pos0 = 0;
10122 dgst_pos1 = 1;
10123 dgst_pos2 = 2;
10124 dgst_pos3 = 3;
10125 break;
10126
10127 case 12600: hash_type = HASH_TYPE_SHA256;
10128 salt_type = SALT_TYPE_INTERN;
10129 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10130 opts_type = OPTS_TYPE_PT_GENERATE_BE
10131 | OPTS_TYPE_PT_ADD80;
10132 kern_type = KERN_TYPE_CF10;
10133 dgst_size = DGST_SIZE_4_8;
10134 parse_func = cf10_parse_hash;
10135 sort_by_digest = sort_by_digest_4_8;
10136 opti_type = OPTI_TYPE_ZERO_BYTE
10137 | OPTI_TYPE_PRECOMPUTE_INIT
10138 | OPTI_TYPE_EARLY_SKIP
10139 | OPTI_TYPE_NOT_ITERATED;
10140 dgst_pos0 = 3;
10141 dgst_pos1 = 7;
10142 dgst_pos2 = 2;
10143 dgst_pos3 = 6;
10144 break;
10145
10146 case 12700: hash_type = HASH_TYPE_AES;
10147 salt_type = SALT_TYPE_EMBEDDED;
10148 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10149 opts_type = OPTS_TYPE_PT_GENERATE_LE
10150 | OPTS_TYPE_HASH_COPY;
10151 kern_type = KERN_TYPE_MYWALLET;
10152 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10153 parse_func = mywallet_parse_hash;
10154 sort_by_digest = sort_by_digest_4_5;
10155 opti_type = OPTI_TYPE_ZERO_BYTE;
10156 dgst_pos0 = 0;
10157 dgst_pos1 = 1;
10158 dgst_pos2 = 2;
10159 dgst_pos3 = 3;
10160 break;
10161
10162 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10163 salt_type = SALT_TYPE_EMBEDDED;
10164 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10165 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10166 kern_type = KERN_TYPE_MS_DRSR;
10167 dgst_size = DGST_SIZE_4_8;
10168 parse_func = ms_drsr_parse_hash;
10169 sort_by_digest = sort_by_digest_4_8;
10170 opti_type = OPTI_TYPE_ZERO_BYTE;
10171 dgst_pos0 = 0;
10172 dgst_pos1 = 1;
10173 dgst_pos2 = 2;
10174 dgst_pos3 = 3;
10175 break;
10176
10177 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10178 salt_type = SALT_TYPE_EMBEDDED;
10179 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10180 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10181 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10182 dgst_size = DGST_SIZE_4_8;
10183 parse_func = androidfde_samsung_parse_hash;
10184 sort_by_digest = sort_by_digest_4_8;
10185 opti_type = OPTI_TYPE_ZERO_BYTE;
10186 dgst_pos0 = 0;
10187 dgst_pos1 = 1;
10188 dgst_pos2 = 2;
10189 dgst_pos3 = 3;
10190 break;
10191
10192 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10193 salt_type = SALT_TYPE_EMBEDDED;
10194 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10195 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10196 kern_type = KERN_TYPE_RAR5;
10197 dgst_size = DGST_SIZE_4_4;
10198 parse_func = rar5_parse_hash;
10199 sort_by_digest = sort_by_digest_4_4;
10200 opti_type = OPTI_TYPE_ZERO_BYTE;
10201 dgst_pos0 = 0;
10202 dgst_pos1 = 1;
10203 dgst_pos2 = 2;
10204 dgst_pos3 = 3;
10205 break;
10206
10207 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10208 salt_type = SALT_TYPE_EMBEDDED;
10209 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10210 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10211 kern_type = KERN_TYPE_KRB5TGS;
10212 dgst_size = DGST_SIZE_4_4;
10213 parse_func = krb5tgs_parse_hash;
10214 sort_by_digest = sort_by_digest_4_4;
10215 opti_type = OPTI_TYPE_ZERO_BYTE
10216 | OPTI_TYPE_NOT_ITERATED;
10217 dgst_pos0 = 0;
10218 dgst_pos1 = 1;
10219 dgst_pos2 = 2;
10220 dgst_pos3 = 3;
10221 break;
10222
10223 case 13200: hash_type = HASH_TYPE_AES;
10224 salt_type = SALT_TYPE_EMBEDDED;
10225 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10226 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10227 kern_type = KERN_TYPE_AXCRYPT;
10228 dgst_size = DGST_SIZE_4_4;
10229 parse_func = axcrypt_parse_hash;
10230 sort_by_digest = sort_by_digest_4_4;
10231 opti_type = OPTI_TYPE_ZERO_BYTE;
10232 dgst_pos0 = 0;
10233 dgst_pos1 = 1;
10234 dgst_pos2 = 2;
10235 dgst_pos3 = 3;
10236 break;
10237
10238 case 13300: hash_type = HASH_TYPE_SHA1;
10239 salt_type = SALT_TYPE_NONE;
10240 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10241 opts_type = OPTS_TYPE_PT_GENERATE_BE
10242 | OPTS_TYPE_PT_ADD80
10243 | OPTS_TYPE_PT_ADDBITS15;
10244 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10245 dgst_size = DGST_SIZE_4_5;
10246 parse_func = sha1axcrypt_parse_hash;
10247 sort_by_digest = sort_by_digest_4_5;
10248 opti_type = OPTI_TYPE_ZERO_BYTE
10249 | OPTI_TYPE_PRECOMPUTE_INIT
10250 | OPTI_TYPE_EARLY_SKIP
10251 | OPTI_TYPE_NOT_ITERATED
10252 | OPTI_TYPE_NOT_SALTED;
10253 dgst_pos0 = 0;
10254 dgst_pos1 = 4;
10255 dgst_pos2 = 3;
10256 dgst_pos3 = 2;
10257 break;
10258
10259 default: usage_mini_print (PROGNAME); return (-1);
10260 }
10261
10262 /**
10263 * parser
10264 */
10265
10266 data.parse_func = parse_func;
10267
10268 /**
10269 * misc stuff
10270 */
10271
10272 if (hex_salt)
10273 {
10274 if (salt_type == SALT_TYPE_INTERN)
10275 {
10276 opts_type |= OPTS_TYPE_ST_HEX;
10277 }
10278 else
10279 {
10280 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10281
10282 return (-1);
10283 }
10284 }
10285
10286 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10287 | (salt_type == SALT_TYPE_EXTERN)
10288 | (salt_type == SALT_TYPE_EMBEDDED)
10289 | (salt_type == SALT_TYPE_VIRTUAL));
10290
10291 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10292
10293 data.hash_type = hash_type;
10294 data.attack_mode = attack_mode;
10295 data.attack_kern = attack_kern;
10296 data.attack_exec = attack_exec;
10297 data.kern_type = kern_type;
10298 data.opts_type = opts_type;
10299 data.dgst_size = dgst_size;
10300 data.salt_type = salt_type;
10301 data.isSalted = isSalted;
10302 data.sort_by_digest = sort_by_digest;
10303 data.dgst_pos0 = dgst_pos0;
10304 data.dgst_pos1 = dgst_pos1;
10305 data.dgst_pos2 = dgst_pos2;
10306 data.dgst_pos3 = dgst_pos3;
10307
10308 esalt_size = 0;
10309
10310 switch (hash_mode)
10311 {
10312 case 2500: esalt_size = sizeof (wpa_t); break;
10313 case 5300: esalt_size = sizeof (ikepsk_t); break;
10314 case 5400: esalt_size = sizeof (ikepsk_t); break;
10315 case 5500: esalt_size = sizeof (netntlm_t); break;
10316 case 5600: esalt_size = sizeof (netntlm_t); break;
10317 case 6211: esalt_size = sizeof (tc_t); break;
10318 case 6212: esalt_size = sizeof (tc_t); break;
10319 case 6213: esalt_size = sizeof (tc_t); break;
10320 case 6221: esalt_size = sizeof (tc_t); break;
10321 case 6222: esalt_size = sizeof (tc_t); break;
10322 case 6223: esalt_size = sizeof (tc_t); break;
10323 case 6231: esalt_size = sizeof (tc_t); break;
10324 case 6232: esalt_size = sizeof (tc_t); break;
10325 case 6233: esalt_size = sizeof (tc_t); break;
10326 case 6241: esalt_size = sizeof (tc_t); break;
10327 case 6242: esalt_size = sizeof (tc_t); break;
10328 case 6243: esalt_size = sizeof (tc_t); break;
10329 case 6600: esalt_size = sizeof (agilekey_t); break;
10330 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10331 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10332 case 7300: esalt_size = sizeof (rakp_t); break;
10333 case 7500: esalt_size = sizeof (krb5pa_t); break;
10334 case 8200: esalt_size = sizeof (cloudkey_t); break;
10335 case 8800: esalt_size = sizeof (androidfde_t); break;
10336 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10337 case 9400: esalt_size = sizeof (office2007_t); break;
10338 case 9500: esalt_size = sizeof (office2010_t); break;
10339 case 9600: esalt_size = sizeof (office2013_t); break;
10340 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10341 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10342 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10343 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10344 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10345 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10346 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10347 case 10200: esalt_size = sizeof (cram_md5_t); break;
10348 case 10400: esalt_size = sizeof (pdf_t); break;
10349 case 10410: esalt_size = sizeof (pdf_t); break;
10350 case 10420: esalt_size = sizeof (pdf_t); break;
10351 case 10500: esalt_size = sizeof (pdf_t); break;
10352 case 10600: esalt_size = sizeof (pdf_t); break;
10353 case 10700: esalt_size = sizeof (pdf_t); break;
10354 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10355 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10356 case 11400: esalt_size = sizeof (sip_t); break;
10357 case 11600: esalt_size = sizeof (seven_zip_t); break;
10358 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10359 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10360 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10361 case 13000: esalt_size = sizeof (rar5_t); break;
10362 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10363 }
10364
10365 data.esalt_size = esalt_size;
10366
10367 /**
10368 * choose dictionary parser
10369 */
10370
10371 if (hash_type == HASH_TYPE_LM)
10372 {
10373 get_next_word_func = get_next_word_lm;
10374 }
10375 else if (opts_type & OPTS_TYPE_PT_UPPER)
10376 {
10377 get_next_word_func = get_next_word_uc;
10378 }
10379 else
10380 {
10381 get_next_word_func = get_next_word_std;
10382 }
10383
10384 /**
10385 * dictstat
10386 */
10387
10388 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10389
10390 #ifdef _POSIX
10391 size_t dictstat_nmemb = 0;
10392 #endif
10393
10394 #ifdef _WIN
10395 uint dictstat_nmemb = 0;
10396 #endif
10397
10398 char dictstat[256] = { 0 };
10399
10400 FILE *dictstat_fp = NULL;
10401
10402 if (keyspace == 0)
10403 {
10404 snprintf (dictstat, sizeof (dictstat) - 1, "%s/hashcat.dictstat", profile_dir);
10405
10406 dictstat_fp = fopen (dictstat, "rb");
10407
10408 if (dictstat_fp)
10409 {
10410 #ifdef _POSIX
10411 struct stat tmpstat;
10412
10413 fstat (fileno (dictstat_fp), &tmpstat);
10414 #endif
10415
10416 #ifdef _WIN
10417 struct stat64 tmpstat;
10418
10419 _fstat64 (fileno (dictstat_fp), &tmpstat);
10420 #endif
10421
10422 if (tmpstat.st_mtime < COMPTIME)
10423 {
10424 /* with v0.15 the format changed so we have to ensure user is using a good version
10425 since there is no version-header in the dictstat file */
10426
10427 fclose (dictstat_fp);
10428
10429 unlink (dictstat);
10430 }
10431 else
10432 {
10433 while (!feof (dictstat_fp))
10434 {
10435 dictstat_t d;
10436
10437 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10438
10439 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10440
10441 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10442 {
10443 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10444
10445 return -1;
10446 }
10447 }
10448
10449 fclose (dictstat_fp);
10450 }
10451 }
10452 }
10453
10454 /**
10455 * potfile
10456 */
10457
10458 char potfile[256] = { 0 };
10459
10460 snprintf (potfile, sizeof (potfile) - 1, "%s/%s.pot", session_dir, session);
10461
10462 data.pot_fp = NULL;
10463
10464 FILE *out_fp = NULL;
10465 FILE *pot_fp = NULL;
10466
10467 if (show == 1 || left == 1)
10468 {
10469 pot_fp = fopen (potfile, "rb");
10470
10471 if (pot_fp == NULL)
10472 {
10473 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10474
10475 return (-1);
10476 }
10477
10478 if (outfile != NULL)
10479 {
10480 if ((out_fp = fopen (outfile, "ab")) == NULL)
10481 {
10482 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10483
10484 fclose (pot_fp);
10485
10486 return (-1);
10487 }
10488 }
10489 else
10490 {
10491 out_fp = stdout;
10492 }
10493 }
10494 else
10495 {
10496 if (potfile_disable == 0)
10497 {
10498 pot_fp = fopen (potfile, "ab");
10499
10500 if (pot_fp == NULL)
10501 {
10502 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10503
10504 return (-1);
10505 }
10506
10507 data.pot_fp = pot_fp;
10508 }
10509 }
10510
10511 pot_t *pot = NULL;
10512
10513 uint pot_cnt = 0;
10514 uint pot_avail = 0;
10515
10516 if (show == 1 || left == 1)
10517 {
10518 SUPPRESS_OUTPUT = 1;
10519
10520 pot_avail = count_lines (pot_fp);
10521
10522 rewind (pot_fp);
10523
10524 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10525
10526 uint pot_hashes_avail = 0;
10527
10528 uint line_num = 0;
10529
10530 while (!feof (pot_fp))
10531 {
10532 line_num++;
10533
10534 char line_buf[BUFSIZ] = { 0 };
10535
10536 int line_len = fgetl (pot_fp, line_buf);
10537
10538 if (line_len == 0) continue;
10539
10540 char *plain_buf = line_buf + line_len;
10541
10542 pot_t *pot_ptr = &pot[pot_cnt];
10543
10544 hash_t *hashes_buf = &pot_ptr->hash;
10545
10546 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10547 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10548
10549 if (pot_cnt == pot_hashes_avail)
10550 {
10551 uint pos = 0;
10552
10553 for (pos = 0; pos < INCR_POT; pos++)
10554 {
10555 if ((pot_cnt + pos) >= pot_avail) break;
10556
10557 pot_t *tmp_pot = &pot[pot_cnt + pos];
10558
10559 hash_t *tmp_hash = &tmp_pot->hash;
10560
10561 tmp_hash->digest = mymalloc (dgst_size);
10562
10563 if (isSalted)
10564 {
10565 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10566 }
10567
10568 if (esalt_size)
10569 {
10570 tmp_hash->esalt = mymalloc (esalt_size);
10571 }
10572
10573 pot_hashes_avail++;
10574 }
10575 }
10576
10577 int plain_len = 0;
10578
10579 int parser_status;
10580
10581 int iter = MAX_CUT_TRIES;
10582
10583 do
10584 {
10585 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10586 {
10587 if (line_buf[i] == ':')
10588 {
10589 line_len--;
10590
10591 break;
10592 }
10593 }
10594
10595 if (data.hash_mode != 2500)
10596 {
10597 parser_status = parse_func (line_buf, line_len, hashes_buf);
10598 }
10599 else
10600 {
10601 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10602
10603 if (line_len > max_salt_size)
10604 {
10605 parser_status = PARSER_GLOBAL_LENGTH;
10606 }
10607 else
10608 {
10609 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10610
10611 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10612
10613 hashes_buf->salt->salt_len = line_len;
10614
10615 parser_status = PARSER_OK;
10616 }
10617 }
10618
10619 // if NOT parsed without error, we add the ":" to the plain
10620
10621 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10622 {
10623 plain_len++;
10624 plain_buf--;
10625 }
10626
10627 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10628
10629 if (parser_status < PARSER_GLOBAL_ZERO)
10630 {
10631 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10632
10633 continue;
10634 }
10635
10636 if (plain_len >= 255) continue;
10637
10638 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10639
10640 pot_ptr->plain_len = plain_len;
10641
10642 pot_cnt++;
10643 }
10644
10645 fclose (pot_fp);
10646
10647 SUPPRESS_OUTPUT = 0;
10648
10649 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10650 }
10651
10652 /**
10653 * word len
10654 */
10655
10656 uint pw_min = PW_MIN;
10657 uint pw_max = PW_MAX;
10658
10659 switch (hash_mode)
10660 {
10661 case 400: if (pw_max > 40) pw_max = 40;
10662 break;
10663 case 500: if (pw_max > 16) pw_max = 16;
10664 break;
10665 case 1500: if (pw_max > 8) pw_max = 8;
10666 break;
10667 case 1600: if (pw_max > 16) pw_max = 16;
10668 break;
10669 case 1800: if (pw_max > 16) pw_max = 16;
10670 break;
10671 case 2100: if (pw_max > 16) pw_max = 16;
10672 break;
10673 case 2500: if (pw_min < 8) pw_min = 8;
10674 break;
10675 case 3000: if (pw_max > 7) pw_max = 7;
10676 break;
10677 case 5200: if (pw_max > 24) pw_max = 24;
10678 break;
10679 case 5800: if (pw_max > 16) pw_max = 16;
10680 break;
10681 case 6300: if (pw_max > 16) pw_max = 16;
10682 break;
10683 case 7400: if (pw_max > 16) pw_max = 16;
10684 break;
10685 case 7900: if (pw_max > 48) pw_max = 48;
10686 break;
10687 case 8500: if (pw_max > 8) pw_max = 8;
10688 break;
10689 case 8600: if (pw_max > 16) pw_max = 16;
10690 break;
10691 case 9710: pw_min = 5;
10692 pw_max = 5;
10693 break;
10694 case 9810: pw_min = 5;
10695 pw_max = 5;
10696 break;
10697 case 10410: pw_min = 5;
10698 pw_max = 5;
10699 break;
10700 case 10300: if (pw_max < 3) pw_min = 3;
10701 if (pw_max > 40) pw_max = 40;
10702 break;
10703 case 10500: if (pw_max < 3) pw_min = 3;
10704 if (pw_max > 40) pw_max = 40;
10705 break;
10706 case 10700: if (pw_max > 16) pw_max = 16;
10707 break;
10708 case 11300: if (pw_max > 40) pw_max = 40;
10709 break;
10710 case 12500: if (pw_max > 20) pw_max = 20;
10711 break;
10712 case 12800: if (pw_max > 24) pw_max = 24;
10713 break;
10714 }
10715
10716 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10717 {
10718 switch (attack_kern)
10719 {
10720 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10721 break;
10722 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10723 break;
10724 }
10725 }
10726
10727 /**
10728 * charsets : keep them together for more easy maintainnce
10729 */
10730
10731 cs_t mp_sys[6] = { { { 0 }, 0 } };
10732 cs_t mp_usr[4] = { { { 0 }, 0 } };
10733
10734 mp_setup_sys (mp_sys);
10735
10736 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10737 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10738 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10739 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10740
10741 /**
10742 * load hashes, part I: find input mode, count hashes
10743 */
10744
10745 uint hashlist_mode = 0;
10746 uint hashlist_format = HLFMT_HASHCAT;
10747
10748 uint hashes_avail = 0;
10749
10750 if (benchmark == 0)
10751 {
10752 struct stat f;
10753
10754 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10755
10756 if ((hash_mode == 2500) ||
10757 (hash_mode == 5200) ||
10758 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10759 (hash_mode == 9000))
10760 {
10761 hashlist_mode = HL_MODE_ARG;
10762
10763 char *hashfile = myargv[optind];
10764
10765 data.hashfile = hashfile;
10766
10767 logfile_top_var_string ("target", hashfile);
10768 }
10769
10770 if (hashlist_mode == HL_MODE_ARG)
10771 {
10772 if (hash_mode == 2500)
10773 {
10774 struct stat st;
10775
10776 if (stat (data.hashfile, &st) == -1)
10777 {
10778 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10779
10780 return (-1);
10781 }
10782
10783 hashes_avail = st.st_size / sizeof (hccap_t);
10784 }
10785 else
10786 {
10787 hashes_avail = 1;
10788 }
10789 }
10790 else if (hashlist_mode == HL_MODE_FILE)
10791 {
10792 char *hashfile = myargv[optind];
10793
10794 data.hashfile = hashfile;
10795
10796 logfile_top_var_string ("target", hashfile);
10797
10798 FILE *fp = NULL;
10799
10800 if ((fp = fopen (hashfile, "rb")) == NULL)
10801 {
10802 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10803
10804 return (-1);
10805 }
10806
10807 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10808
10809 hashes_avail = count_lines (fp);
10810
10811 rewind (fp);
10812
10813 if (hashes_avail == 0)
10814 {
10815 log_error ("ERROR: hashfile is empty or corrupt");
10816
10817 fclose (fp);
10818
10819 return (-1);
10820 }
10821
10822 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10823
10824 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10825 {
10826 log_error ("ERROR: remove not supported in native hashfile-format mode");
10827
10828 fclose (fp);
10829
10830 return (-1);
10831 }
10832
10833 fclose (fp);
10834 }
10835 }
10836 else
10837 {
10838 hashlist_mode = HL_MODE_ARG;
10839
10840 hashes_avail = 1;
10841 }
10842
10843 if (hash_mode == 3000) hashes_avail *= 2;
10844
10845 data.hashlist_mode = hashlist_mode;
10846 data.hashlist_format = hashlist_format;
10847
10848 logfile_top_uint (hashlist_mode);
10849 logfile_top_uint (hashlist_format);
10850
10851 /**
10852 * load hashes, part II: allocate required memory, set pointers
10853 */
10854
10855 hash_t *hashes_buf = NULL;
10856 void *digests_buf = NULL;
10857 salt_t *salts_buf = NULL;
10858 void *esalts_buf = NULL;
10859
10860 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10861
10862 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10863
10864 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10865 {
10866 u32 hash_pos;
10867
10868 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10869 {
10870 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10871
10872 hashes_buf[hash_pos].hash_info = hash_info;
10873
10874 if (username && (remove || show || left))
10875 {
10876 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10877 }
10878
10879 if (benchmark)
10880 {
10881 hash_info->orighash = (char *) mymalloc (256);
10882 }
10883 }
10884 }
10885
10886 if (isSalted)
10887 {
10888 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10889
10890 if (esalt_size)
10891 {
10892 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10893 }
10894 }
10895 else
10896 {
10897 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10898 }
10899
10900 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10901 {
10902 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10903
10904 if (isSalted)
10905 {
10906 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10907
10908 if (esalt_size)
10909 {
10910 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10911 }
10912 }
10913 else
10914 {
10915 hashes_buf[hash_pos].salt = &salts_buf[0];
10916 }
10917 }
10918
10919 /**
10920 * load hashes, part III: parse hashes or generate them if benchmark
10921 */
10922
10923 uint hashes_cnt = 0;
10924
10925 if (benchmark == 0)
10926 {
10927 if (keyspace == 1)
10928 {
10929 // useless to read hash file for keyspace, cheat a little bit w/ optind
10930 }
10931 else if (hashes_avail == 0)
10932 {
10933 }
10934 else if (hashlist_mode == HL_MODE_ARG)
10935 {
10936 char *input_buf = myargv[optind];
10937
10938 uint input_len = strlen (input_buf);
10939
10940 logfile_top_var_string ("target", input_buf);
10941
10942 char *hash_buf = NULL;
10943 int hash_len = 0;
10944
10945 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10946
10947 bool hash_fmt_error = 0;
10948
10949 if (hash_len < 1) hash_fmt_error = 1;
10950 if (hash_buf == NULL) hash_fmt_error = 1;
10951
10952 if (hash_fmt_error)
10953 {
10954 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
10955 }
10956 else
10957 {
10958 if (opts_type & OPTS_TYPE_HASH_COPY)
10959 {
10960 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10961
10962 hash_info_tmp->orighash = mystrdup (hash_buf);
10963 }
10964
10965 if (isSalted)
10966 {
10967 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
10968 }
10969
10970 int parser_status = PARSER_OK;
10971
10972 if (hash_mode == 2500)
10973 {
10974 if (hash_len == 0)
10975 {
10976 log_error ("ERROR: hccap file not specified");
10977
10978 return (-1);
10979 }
10980
10981 hashlist_mode = HL_MODE_FILE;
10982
10983 data.hashlist_mode = hashlist_mode;
10984
10985 FILE *fp = fopen (hash_buf, "rb");
10986
10987 if (fp == NULL)
10988 {
10989 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
10990
10991 return (-1);
10992 }
10993
10994 if (hashes_avail < 1)
10995 {
10996 log_error ("ERROR: hccap file is empty or corrupt");
10997
10998 fclose (fp);
10999
11000 return (-1);
11001 }
11002
11003 uint hccap_size = sizeof (hccap_t);
11004
11005 char *in = (char *) mymalloc (hccap_size);
11006
11007 while (!feof (fp))
11008 {
11009 int n = fread (in, hccap_size, 1, fp);
11010
11011 if (n != 1)
11012 {
11013 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11014
11015 break;
11016 }
11017
11018 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11019
11020 if (parser_status != PARSER_OK)
11021 {
11022 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11023
11024 continue;
11025 }
11026
11027 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11028
11029 if ((show == 1) || (left == 1))
11030 {
11031 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11032
11033 char *salt_ptr = (char *) tmp_salt->salt_buf;
11034
11035 int cur_pos = tmp_salt->salt_len;
11036 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11037
11038 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11039
11040 u8 *pke_ptr = (u8 *) wpa->pke;
11041
11042 // do the appending task
11043
11044 snprintf (salt_ptr + cur_pos,
11045 rem_len,
11046 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11047 pke_ptr[20], pke_ptr[27], pke_ptr[26], pke_ptr[25], pke_ptr[24], pke_ptr[31], // MAC1
11048 pke_ptr[30], pke_ptr[29], pke_ptr[28], pke_ptr[35], pke_ptr[34], pke_ptr[33]); // MAC2
11049
11050
11051 // memset () the remaining part of the salt
11052
11053 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11054 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11055
11056 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11057
11058 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11059 }
11060
11061 if (show == 1) handle_show_request (pot, pot_cnt, (char *) hashes_buf[hashes_cnt].salt->salt_buf, hashes_buf[hashes_cnt].salt->salt_len, &hashes_buf[hashes_cnt], sort_by_salt_buf, out_fp);
11062 if (left == 1) handle_left_request (pot, pot_cnt, (char *) hashes_buf[hashes_cnt].salt->salt_buf, hashes_buf[hashes_cnt].salt->salt_len, &hashes_buf[hashes_cnt], sort_by_salt_buf, out_fp);
11063
11064 hashes_cnt++;
11065 }
11066
11067 fclose (fp);
11068
11069 myfree (in);
11070 }
11071 else if (hash_mode == 3000)
11072 {
11073 if (hash_len == 32)
11074 {
11075 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11076
11077 hash_t *lm_hash_left = NULL;
11078
11079 if (parser_status == PARSER_OK)
11080 {
11081 lm_hash_left = &hashes_buf[hashes_cnt];
11082
11083 hashes_cnt++;
11084 }
11085 else
11086 {
11087 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11088 }
11089
11090 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11091
11092 hash_t *lm_hash_right = NULL;
11093
11094 if (parser_status == PARSER_OK)
11095 {
11096 lm_hash_right = &hashes_buf[hashes_cnt];
11097
11098 hashes_cnt++;
11099 }
11100 else
11101 {
11102 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11103 }
11104
11105 // show / left
11106
11107 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11108 {
11109 if (show == 1) handle_show_request_lm (pot, pot_cnt, input_buf, input_len, lm_hash_left, lm_hash_right, sort_by_pot, out_fp);
11110 if (left == 1) handle_left_request_lm (pot, pot_cnt, input_buf, input_len, lm_hash_left, lm_hash_right, sort_by_pot, out_fp);
11111 }
11112 }
11113 else
11114 {
11115 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11116
11117 if (parser_status == PARSER_OK)
11118 {
11119 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11120 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11121 }
11122
11123 if (parser_status == PARSER_OK)
11124 {
11125 hashes_cnt++;
11126 }
11127 else
11128 {
11129 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11130 }
11131 }
11132 }
11133 else
11134 {
11135 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11136
11137 if (parser_status == PARSER_OK)
11138 {
11139 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11140 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11141 }
11142
11143 if (parser_status == PARSER_OK)
11144 {
11145 hashes_cnt++;
11146 }
11147 else
11148 {
11149 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11150 }
11151 }
11152 }
11153 }
11154 else if (hashlist_mode == HL_MODE_FILE)
11155 {
11156 char *hashfile = data.hashfile;
11157
11158 FILE *fp;
11159
11160 if ((fp = fopen (hashfile, "rb")) == NULL)
11161 {
11162 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11163
11164 return (-1);
11165 }
11166
11167 uint line_num = 0;
11168
11169 while (!feof (fp))
11170 {
11171 line_num++;
11172
11173 char line_buf[BUFSIZ] = { 0 };
11174
11175 int line_len = fgetl (fp, line_buf);
11176
11177 if (line_len == 0) continue;
11178
11179 char *hash_buf = NULL;
11180 int hash_len = 0;
11181
11182 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11183
11184 bool hash_fmt_error = 0;
11185
11186 if (hash_len < 1) hash_fmt_error = 1;
11187 if (hash_buf == NULL) hash_fmt_error = 1;
11188
11189 if (hash_fmt_error)
11190 {
11191 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11192
11193 continue;
11194 }
11195
11196 if (username)
11197 {
11198 char *user_buf = NULL;
11199 int user_len = 0;
11200
11201 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11202
11203 if (remove || show)
11204 {
11205 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11206
11207 *user = (user_t *) mymalloc (sizeof (user_t));
11208
11209 user_t *user_ptr = *user;
11210
11211 if (user_buf != NULL)
11212 {
11213 user_ptr->user_name = mystrdup (user_buf);
11214 }
11215 else
11216 {
11217 user_ptr->user_name = mystrdup ("");
11218 }
11219
11220 user_ptr->user_len = user_len;
11221 }
11222 }
11223
11224 if (opts_type & OPTS_TYPE_HASH_COPY)
11225 {
11226 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11227
11228 hash_info_tmp->orighash = mystrdup (hash_buf);
11229 }
11230
11231 if (isSalted)
11232 {
11233 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11234 }
11235
11236 if (hash_mode == 3000)
11237 {
11238 if (hash_len == 32)
11239 {
11240 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11241
11242 if (parser_status < PARSER_GLOBAL_ZERO)
11243 {
11244 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11245
11246 continue;
11247 }
11248
11249 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11250
11251 hashes_cnt++;
11252
11253 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11254
11255 if (parser_status < PARSER_GLOBAL_ZERO)
11256 {
11257 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11258
11259 continue;
11260 }
11261
11262 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11263
11264 if (data.quiet == 0) if ((hashes_cnt % 0x20000) == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_cnt, hashes_avail, ((float) hashes_cnt / hashes_avail) * 100);
11265
11266 hashes_cnt++;
11267
11268 // show / left
11269
11270 if (show == 1) handle_show_request_lm (pot, pot_cnt, line_buf, line_len, lm_hash_left, lm_hash_right, sort_by_pot, out_fp);
11271 if (left == 1) handle_left_request_lm (pot, pot_cnt, line_buf, line_len, lm_hash_left, lm_hash_right, sort_by_pot, out_fp);
11272 }
11273 else
11274 {
11275 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11276
11277 if (parser_status < PARSER_GLOBAL_ZERO)
11278 {
11279 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11280
11281 continue;
11282 }
11283
11284 if (data.quiet == 0) if ((hashes_cnt % 0x20000) == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_cnt, hashes_avail, ((float) hashes_cnt / hashes_avail) * 100);
11285
11286 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11287 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11288
11289 hashes_cnt++;
11290 }
11291 }
11292 else
11293 {
11294 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11295
11296 if (parser_status < PARSER_GLOBAL_ZERO)
11297 {
11298 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11299
11300 continue;
11301 }
11302
11303 if (data.quiet == 0) if ((hashes_cnt % 0x20000) == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_cnt, hashes_avail, ((float) hashes_cnt / hashes_avail) * 100);
11304
11305 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11306 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11307
11308 hashes_cnt++;
11309 }
11310 }
11311
11312 fclose (fp);
11313
11314 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11315
11316 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11317 }
11318 }
11319 else
11320 {
11321 if (isSalted)
11322 {
11323 hashes_buf[0].salt->salt_len = 8;
11324
11325 // special salt handling
11326
11327 switch (hash_mode)
11328 {
11329 case 1500: hashes_buf[0].salt->salt_len = 2;
11330 break;
11331 case 1731: hashes_buf[0].salt->salt_len = 4;
11332 break;
11333 case 2410: hashes_buf[0].salt->salt_len = 4;
11334 break;
11335 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11336 break;
11337 case 3100: hashes_buf[0].salt->salt_len = 1;
11338 break;
11339 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11340 break;
11341 case 5800: hashes_buf[0].salt->salt_len = 16;
11342 break;
11343 case 6800: hashes_buf[0].salt->salt_len = 32;
11344 break;
11345 case 8400: hashes_buf[0].salt->salt_len = 40;
11346 break;
11347 case 8800: hashes_buf[0].salt->salt_len = 16;
11348 break;
11349 case 8900: hashes_buf[0].salt->salt_len = 16;
11350 hashes_buf[0].salt->scrypt_N = 1024;
11351 hashes_buf[0].salt->scrypt_r = 1;
11352 hashes_buf[0].salt->scrypt_p = 1;
11353 break;
11354 case 9100: hashes_buf[0].salt->salt_len = 16;
11355 break;
11356 case 9300: hashes_buf[0].salt->salt_len = 14;
11357 hashes_buf[0].salt->scrypt_N = 16384;
11358 hashes_buf[0].salt->scrypt_r = 1;
11359 hashes_buf[0].salt->scrypt_p = 1;
11360 break;
11361 case 9400: hashes_buf[0].salt->salt_len = 16;
11362 break;
11363 case 9500: hashes_buf[0].salt->salt_len = 16;
11364 break;
11365 case 9600: hashes_buf[0].salt->salt_len = 16;
11366 break;
11367 case 9700: hashes_buf[0].salt->salt_len = 16;
11368 break;
11369 case 9710: hashes_buf[0].salt->salt_len = 16;
11370 break;
11371 case 9720: hashes_buf[0].salt->salt_len = 16;
11372 break;
11373 case 9800: hashes_buf[0].salt->salt_len = 16;
11374 break;
11375 case 9810: hashes_buf[0].salt->salt_len = 16;
11376 break;
11377 case 9820: hashes_buf[0].salt->salt_len = 16;
11378 break;
11379 case 10300: hashes_buf[0].salt->salt_len = 12;
11380 break;
11381 case 11500: hashes_buf[0].salt->salt_len = 4;
11382 break;
11383 case 11600: hashes_buf[0].salt->salt_len = 4;
11384 break;
11385 case 12400: hashes_buf[0].salt->salt_len = 4;
11386 break;
11387 case 12500: hashes_buf[0].salt->salt_len = 8;
11388 break;
11389 case 12600: hashes_buf[0].salt->salt_len = 64;
11390 break;
11391 }
11392
11393 // special esalt handling
11394
11395 switch (hash_mode)
11396 {
11397 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11398 break;
11399 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11400 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11401 break;
11402 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11403 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11404 break;
11405 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11406 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11407 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11408 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11409 break;
11410 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11411 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11412 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11413 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11414 break;
11415 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11416 break;
11417 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11418 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11419 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11420 break;
11421 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11422 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11423 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11424 break;
11425 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11426 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11427 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11428 break;
11429 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11430 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11431 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11432 break;
11433 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11434 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11435 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11436 break;
11437 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11438 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11439 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11440 break;
11441 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11442 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11443 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11444 break;
11445 }
11446 }
11447
11448 // set hashfile
11449
11450 switch (hash_mode)
11451 {
11452 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11453 break;
11454 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11455 break;
11456 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11457 break;
11458 case 6211: data.hashfile = mystrdup ("hashcat.tc");
11459 break;
11460 case 6212: data.hashfile = mystrdup ("hashcat.tc");
11461 break;
11462 case 6213: data.hashfile = mystrdup ("hashcat.tc");
11463 break;
11464 case 6221: data.hashfile = mystrdup ("hashcat.tc");
11465 break;
11466 case 6222: data.hashfile = mystrdup ("hashcat.tc");
11467 break;
11468 case 6223: data.hashfile = mystrdup ("hashcat.tc");
11469 break;
11470 case 6231: data.hashfile = mystrdup ("hashcat.tc");
11471 break;
11472 case 6232: data.hashfile = mystrdup ("hashcat.tc");
11473 break;
11474 case 6233: data.hashfile = mystrdup ("hashcat.tc");
11475 break;
11476 case 6241: data.hashfile = mystrdup ("hashcat.tc");
11477 break;
11478 case 6242: data.hashfile = mystrdup ("hashcat.tc");
11479 break;
11480 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11481 break;
11482 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11483 break;
11484 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11485 break;
11486 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11487 break;
11488 }
11489
11490 // set default iterations
11491
11492 switch (hash_mode)
11493 {
11494 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11495 break;
11496 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11497 break;
11498 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11499 break;
11500 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11501 break;
11502 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11503 break;
11504 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11505 break;
11506 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11507 break;
11508 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11509 break;
11510 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11511 break;
11512 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11513 break;
11514 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11515 break;
11516 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11517 break;
11518 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11519 break;
11520 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11521 break;
11522 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11523 break;
11524 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11525 break;
11526 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11527 break;
11528 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11529 break;
11530 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11531 break;
11532 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11533 break;
11534 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11535 break;
11536 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11537 break;
11538 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11539 break;
11540 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11541 break;
11542 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11543 break;
11544 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11545 break;
11546 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11547 break;
11548 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11549 break;
11550 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11551 break;
11552 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11553 break;
11554 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11555 break;
11556 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11557 break;
11558 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11559 break;
11560 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11561 break;
11562 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11563 break;
11564 case 8900: hashes_buf[0].salt->salt_iter = 1;
11565 break;
11566 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11567 break;
11568 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11569 break;
11570 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11571 break;
11572 case 9300: hashes_buf[0].salt->salt_iter = 1;
11573 break;
11574 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11575 break;
11576 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11577 break;
11578 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11579 break;
11580 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11581 break;
11582 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11583 break;
11584 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11585 break;
11586 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11587 break;
11588 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11589 break;
11590 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11591 break;
11592 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11593 break;
11594 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11595 break;
11596 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11597 break;
11598 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11599 break;
11600 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11601 break;
11602 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11603 break;
11604 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11605 break;
11606 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11607 break;
11608 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11609 break;
11610 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11611 break;
11612 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11613 break;
11614 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11615 break;
11616 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
11617 break;
11618 }
11619
11620 hashes_cnt = 1;
11621 }
11622
11623 if (show == 1 || left == 1)
11624 {
11625 for (uint i = 0; i < pot_cnt; i++)
11626 {
11627 pot_t *pot_ptr = &pot[i];
11628
11629 hash_t *hashes_buf = &pot_ptr->hash;
11630
11631 local_free (hashes_buf->digest);
11632
11633 if (isSalted)
11634 {
11635 local_free (hashes_buf->salt);
11636 }
11637 }
11638
11639 local_free (pot);
11640
11641 if (data.quiet == 0) log_info_nn ("");
11642
11643 return (0);
11644 }
11645
11646 if (keyspace == 0)
11647 {
11648 if (hashes_cnt == 0)
11649 {
11650 log_error ("ERROR: No hashes loaded");
11651
11652 return (-1);
11653 }
11654 }
11655
11656 /**
11657 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11658 */
11659
11660 if (data.outfile != NULL)
11661 {
11662 if (data.hashfile != NULL)
11663 {
11664 #ifdef _POSIX
11665 struct stat tmpstat_outfile;
11666 struct stat tmpstat_hashfile;
11667 #endif
11668
11669 #ifdef _WIN
11670 struct stat64 tmpstat_outfile;
11671 struct stat64 tmpstat_hashfile;
11672 #endif
11673
11674 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11675
11676 if (tmp_outfile_fp)
11677 {
11678 #ifdef _POSIX
11679 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11680 #endif
11681
11682 #ifdef _WIN
11683 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11684 #endif
11685
11686 fclose (tmp_outfile_fp);
11687 }
11688
11689 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11690
11691 if (tmp_hashfile_fp)
11692 {
11693 #ifdef _POSIX
11694 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11695 #endif
11696
11697 #ifdef _WIN
11698 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11699 #endif
11700
11701 fclose (tmp_hashfile_fp);
11702 }
11703
11704 if (tmp_outfile_fp && tmp_outfile_fp)
11705 {
11706 tmpstat_outfile.st_mode = 0;
11707 tmpstat_outfile.st_nlink = 0;
11708 tmpstat_outfile.st_uid = 0;
11709 tmpstat_outfile.st_gid = 0;
11710 tmpstat_outfile.st_rdev = 0;
11711 tmpstat_outfile.st_atime = 0;
11712
11713 tmpstat_hashfile.st_mode = 0;
11714 tmpstat_hashfile.st_nlink = 0;
11715 tmpstat_hashfile.st_uid = 0;
11716 tmpstat_hashfile.st_gid = 0;
11717 tmpstat_hashfile.st_rdev = 0;
11718 tmpstat_hashfile.st_atime = 0;
11719
11720 #ifdef _POSIX
11721 tmpstat_outfile.st_blksize = 0;
11722 tmpstat_outfile.st_blocks = 0;
11723
11724 tmpstat_hashfile.st_blksize = 0;
11725 tmpstat_hashfile.st_blocks = 0;
11726 #endif
11727
11728 #ifdef _POSIX
11729 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11730 {
11731 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11732
11733 return (-1);
11734 }
11735 #endif
11736
11737 #ifdef _WIN
11738 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11739 {
11740 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11741
11742 return (-1);
11743 }
11744 #endif
11745 }
11746 }
11747 }
11748
11749 /**
11750 * Remove duplicates
11751 */
11752
11753 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11754
11755 if (isSalted)
11756 {
11757 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11758 }
11759 else
11760 {
11761 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11762 }
11763
11764 uint hashes_cnt_orig = hashes_cnt;
11765
11766 hashes_cnt = 1;
11767
11768 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11769 {
11770 if (isSalted)
11771 {
11772 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11773 {
11774 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11775 }
11776 }
11777 else
11778 {
11779 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11780 }
11781
11782 if (hashes_pos > hashes_cnt)
11783 {
11784 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11785 }
11786
11787 hashes_cnt++;
11788 }
11789
11790 /**
11791 * Potfile removes
11792 */
11793
11794 uint potfile_remove_cracks = 0;
11795
11796 if (potfile_disable == 0)
11797 {
11798 hash_t hash_buf;
11799
11800 hash_buf.digest = mymalloc (dgst_size);
11801 hash_buf.salt = NULL;
11802 hash_buf.esalt = NULL;
11803 hash_buf.hash_info = NULL;
11804 hash_buf.cracked = 0;
11805
11806 if (isSalted)
11807 {
11808 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11809 }
11810
11811 if (esalt_size)
11812 {
11813 hash_buf.esalt = mymalloc (esalt_size);
11814 }
11815
11816 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11817
11818 // no solution for these special hash types (for instane because they use hashfile in output etc)
11819 if ((hash_mode != 5200) &&
11820 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11821 (hash_mode != 9000))
11822 {
11823 FILE *fp = fopen (potfile, "rb");
11824
11825 if (fp != NULL)
11826 {
11827 while (!feof (fp))
11828 {
11829 char line_buf[BUFSIZ] = { 0 };
11830
11831 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
11832
11833 if (ptr == NULL) break;
11834
11835 int line_len = strlen (line_buf);
11836
11837 if (line_len == 0) continue;
11838
11839 int iter = MAX_CUT_TRIES;
11840
11841 for (int i = line_len - 1; i && iter; i--, line_len--)
11842 {
11843 if (line_buf[i] != ':') continue;
11844
11845 if (isSalted)
11846 {
11847 memset (hash_buf.salt, 0, sizeof (salt_t));
11848 }
11849
11850 hash_t *found = NULL;
11851
11852 if (hash_mode == 6800)
11853 {
11854 if (i < 64) // 64 = 16 * uint in salt_buf[]
11855 {
11856 // manipulate salt_buf
11857 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11858
11859 hash_buf.salt->salt_len = i;
11860
11861 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11862 }
11863 }
11864 else if (hash_mode == 2500)
11865 {
11866 if (i < 64) // 64 = 16 * uint in salt_buf[]
11867 {
11868 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11869 // manipulate salt_buf
11870
11871 // to be safe work with a copy (because of line_len loop, i etc)
11872
11873 char line_buf_cpy[BUFSIZ] = { 0 };
11874
11875 memcpy (line_buf_cpy, line_buf, i);
11876
11877 char *mac2_pos = strrchr (line_buf_cpy, ':');
11878
11879 if (mac2_pos == NULL) continue;
11880
11881 mac2_pos[0] = 0;
11882 mac2_pos++;
11883
11884 if (strlen (mac2_pos) != 12) continue;
11885
11886 char *mac1_pos = strrchr (line_buf_cpy, ':');
11887
11888 if (mac1_pos == NULL) continue;
11889
11890 mac1_pos[0] = 0;
11891 mac1_pos++;
11892
11893 if (strlen (mac1_pos) != 12) continue;
11894
11895 uint essid_length = mac1_pos - line_buf_cpy - 1;
11896
11897 // here we need the ESSID
11898 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11899
11900 hash_buf.salt->salt_len = essid_length;
11901
11902 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11903
11904 if (found)
11905 {
11906 wpa_t *wpa = (wpa_t *) found->esalt;
11907
11908 uint pke[25] = { 0 };
11909
11910 char *pke_ptr = (char *) pke;
11911
11912 for (uint i = 0; i < 25; i++)
11913 {
11914 pke[i] = byte_swap_32 (wpa->pke[i]);
11915 }
11916
11917 u8 mac1[6] = { 0 };
11918 u8 mac2[6] = { 0 };
11919
11920 memcpy (mac1, pke_ptr + 23, 6);
11921 memcpy (mac2, pke_ptr + 29, 6);
11922
11923 // compare hex string(s) vs binary MAC address(es)
11924
11925 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11926 {
11927 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
11928 {
11929 found = NULL;
11930 break;
11931 }
11932 }
11933
11934 // early skip ;)
11935 if (!found) continue;
11936
11937 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11938 {
11939 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
11940 {
11941 found = NULL;
11942 break;
11943 }
11944 }
11945 }
11946 }
11947 }
11948 else
11949 {
11950 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
11951
11952 if (parser_status == PARSER_OK)
11953 {
11954 if (isSalted)
11955 {
11956 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11957 }
11958 else
11959 {
11960 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11961 }
11962 }
11963 }
11964
11965 if (found == NULL) continue;
11966
11967 if (!found->cracked) potfile_remove_cracks++;
11968
11969 found->cracked = 1;
11970
11971 if (found) break;
11972
11973 iter--;
11974 }
11975 }
11976
11977 fclose (fp);
11978 }
11979 }
11980
11981 if (esalt_size)
11982 {
11983 local_free (hash_buf.esalt);
11984 }
11985
11986 if (isSalted)
11987 {
11988 local_free (hash_buf.salt);
11989 }
11990
11991 local_free (hash_buf.digest);
11992 }
11993
11994 /**
11995 * Now generate all the buffers required for later
11996 */
11997
11998 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
11999
12000 salt_t *salts_buf_new = NULL;
12001 void *esalts_buf_new = NULL;
12002
12003 if (isSalted)
12004 {
12005 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12006
12007 if (esalt_size)
12008 {
12009 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12010 }
12011 }
12012 else
12013 {
12014 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12015 }
12016
12017 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12018
12019 uint digests_cnt = hashes_cnt;
12020 uint digests_done = 0;
12021
12022 uint size_digests = digests_cnt * dgst_size;
12023 uint size_shown = digests_cnt * sizeof (uint);
12024
12025 uint *digests_shown = (uint *) mymalloc (size_shown);
12026 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12027
12028 uint salts_cnt = 0;
12029 uint salts_done = 0;
12030
12031 hashinfo_t **hash_info = NULL;
12032
12033 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12034 {
12035 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12036
12037 if (username && (remove || show))
12038 {
12039 uint user_pos;
12040
12041 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12042 {
12043 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12044
12045 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12046 }
12047 }
12048 }
12049
12050 uint *salts_shown = (uint *) mymalloc (size_shown);
12051
12052 salt_t *salt_buf;
12053
12054 {
12055 // copied from inner loop
12056
12057 salt_buf = &salts_buf_new[salts_cnt];
12058
12059 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12060
12061 if (esalt_size)
12062 {
12063 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12064 }
12065
12066 salt_buf->digests_cnt = 0;
12067 salt_buf->digests_done = 0;
12068 salt_buf->digests_offset = 0;
12069
12070 salts_cnt++;
12071 }
12072
12073 if (hashes_buf[0].cracked == 1)
12074 {
12075 digests_shown[0] = 1;
12076
12077 digests_done++;
12078
12079 salt_buf->digests_done++;
12080 }
12081
12082 salt_buf->digests_cnt++;
12083
12084 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12085
12086 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12087 {
12088 hash_info[0] = hashes_buf[0].hash_info;
12089 }
12090
12091 // copy from inner loop
12092
12093 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12094 {
12095 if (isSalted)
12096 {
12097 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12098 {
12099 salt_buf = &salts_buf_new[salts_cnt];
12100
12101 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12102
12103 if (esalt_size)
12104 {
12105 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12106 }
12107
12108 salt_buf->digests_cnt = 0;
12109 salt_buf->digests_done = 0;
12110 salt_buf->digests_offset = hashes_pos;
12111
12112 salts_cnt++;
12113 }
12114 }
12115
12116 if (hashes_buf[hashes_pos].cracked == 1)
12117 {
12118 digests_shown[hashes_pos] = 1;
12119
12120 digests_done++;
12121
12122 salt_buf->digests_done++;
12123 }
12124
12125 salt_buf->digests_cnt++;
12126
12127 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12128
12129 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12130 {
12131 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12132 }
12133 }
12134
12135 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12136 {
12137 salt_t *salt_buf = &salts_buf_new[salt_pos];
12138
12139 if (salt_buf->digests_done == salt_buf->digests_cnt)
12140 {
12141 salts_shown[salt_pos] = 1;
12142
12143 salts_done++;
12144 }
12145
12146 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12147 }
12148
12149 local_free (digests_buf);
12150 local_free (salts_buf);
12151 local_free (esalts_buf);
12152
12153 digests_buf = digests_buf_new;
12154 salts_buf = salts_buf_new;
12155 esalts_buf = esalts_buf_new;
12156
12157 local_free (hashes_buf);
12158
12159 /**
12160 * special modification not set from parser
12161 */
12162
12163 switch (hash_mode)
12164 {
12165 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12166 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12167 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12168 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12169 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12170 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12171 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12172 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12173 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12174 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12175 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12176 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12177 }
12178
12179 if (truecrypt_keyfiles)
12180 {
12181 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12182
12183 char *keyfiles = strdup (truecrypt_keyfiles);
12184
12185 char *keyfile = strtok (keyfiles, ",");
12186
12187 do
12188 {
12189 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12190
12191 } while ((keyfile = strtok (NULL, ",")) != NULL);
12192
12193 free (keyfiles);
12194 }
12195
12196 data.digests_cnt = digests_cnt;
12197 data.digests_done = digests_done;
12198 data.digests_buf = digests_buf;
12199 data.digests_shown = digests_shown;
12200 data.digests_shown_tmp = digests_shown_tmp;
12201
12202 data.salts_cnt = salts_cnt;
12203 data.salts_done = salts_done;
12204 data.salts_buf = salts_buf;
12205 data.salts_shown = salts_shown;
12206
12207 data.esalts_buf = esalts_buf;
12208 data.hash_info = hash_info;
12209
12210 /**
12211 * Automatic Optimizers
12212 */
12213
12214 if (salts_cnt == 1)
12215 opti_type |= OPTI_TYPE_SINGLE_SALT;
12216
12217 if (digests_cnt == 1)
12218 opti_type |= OPTI_TYPE_SINGLE_HASH;
12219
12220 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12221 opti_type |= OPTI_TYPE_NOT_ITERATED;
12222
12223 if (attack_mode == ATTACK_MODE_BF)
12224 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12225
12226 data.opti_type = opti_type;
12227
12228 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12229 {
12230 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12231 {
12232 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12233 {
12234 if (opts_type & OPTS_TYPE_ST_ADD80)
12235 {
12236 opts_type &= ~OPTS_TYPE_ST_ADD80;
12237 opts_type |= OPTS_TYPE_PT_ADD80;
12238 }
12239
12240 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12241 {
12242 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12243 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12244 }
12245
12246 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12247 {
12248 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12249 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12250 }
12251 }
12252 }
12253 }
12254
12255 /**
12256 * Some algorithm, like descrypt, can benefit from JIT compilation
12257 */
12258
12259 int force_jit_compilation = -1;
12260
12261 if (hash_mode == 8900)
12262 {
12263 force_jit_compilation = 8900;
12264 }
12265 else if (hash_mode == 9300)
12266 {
12267 force_jit_compilation = 8900;
12268 }
12269 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12270 {
12271 force_jit_compilation = 1500;
12272 }
12273
12274 /**
12275 * generate bitmap tables
12276 */
12277
12278 const uint bitmap_shift1 = 5;
12279 const uint bitmap_shift2 = 13;
12280
12281 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12282
12283 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12284 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12285 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12286 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12287 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12288 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12289 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12290 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12291
12292 uint bitmap_bits;
12293 uint bitmap_nums;
12294 uint bitmap_mask;
12295 uint bitmap_size;
12296
12297 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12298 {
12299 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12300
12301 bitmap_nums = 1 << bitmap_bits;
12302
12303 bitmap_mask = bitmap_nums - 1;
12304
12305 bitmap_size = bitmap_nums * sizeof (uint);
12306
12307 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12308
12309 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;
12310 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;
12311
12312 break;
12313 }
12314
12315 bitmap_nums = 1 << bitmap_bits;
12316
12317 bitmap_mask = bitmap_nums - 1;
12318
12319 bitmap_size = bitmap_nums * sizeof (uint);
12320
12321 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);
12322 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);
12323
12324 /**
12325 * prepare quick rule
12326 */
12327
12328 data.rule_buf_l = rule_buf_l;
12329 data.rule_buf_r = rule_buf_r;
12330
12331 int rule_len_l = (int) strlen (rule_buf_l);
12332 int rule_len_r = (int) strlen (rule_buf_r);
12333
12334 data.rule_len_l = rule_len_l;
12335 data.rule_len_r = rule_len_r;
12336
12337 /**
12338 * load rules
12339 */
12340
12341 uint *all_kernel_rules_cnt = NULL;
12342
12343 kernel_rule_t **all_kernel_rules_buf = NULL;
12344
12345 if (rp_files_cnt)
12346 {
12347 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12348
12349 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12350 }
12351
12352 char rule_buf[BUFSIZ] = { 0 };
12353
12354 int rule_len = 0;
12355
12356 for (uint i = 0; i < rp_files_cnt; i++)
12357 {
12358 uint kernel_rules_avail = 0;
12359
12360 uint kernel_rules_cnt = 0;
12361
12362 kernel_rule_t *kernel_rules_buf = NULL;
12363
12364 char *rp_file = rp_files[i];
12365
12366 char in[BLOCK_SIZE] = { 0 };
12367 char out[BLOCK_SIZE] = { 0 };
12368
12369 FILE *fp = NULL;
12370
12371 uint rule_line = 0;
12372
12373 if ((fp = fopen (rp_file, "rb")) == NULL)
12374 {
12375 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12376
12377 return (-1);
12378 }
12379
12380 while (!feof (fp))
12381 {
12382 memset (rule_buf, 0, BUFSIZ);
12383
12384 rule_len = fgetl (fp, rule_buf);
12385
12386 rule_line++;
12387
12388 if (rule_len == 0) continue;
12389
12390 if (rule_buf[0] == '#') continue;
12391
12392 if (kernel_rules_avail == kernel_rules_cnt)
12393 {
12394 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12395
12396 kernel_rules_avail += INCR_RULES;
12397 }
12398
12399 memset (in, 0, BLOCK_SIZE);
12400 memset (out, 0, BLOCK_SIZE);
12401
12402 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12403
12404 if (result == -1)
12405 {
12406 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12407
12408 continue;
12409 }
12410
12411 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12412 {
12413 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12414
12415 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12416
12417 continue;
12418 }
12419
12420 /* its so slow
12421 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12422 {
12423 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12424
12425 continue;
12426 }
12427 */
12428
12429 kernel_rules_cnt++;
12430 }
12431
12432 fclose (fp);
12433
12434 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12435
12436 all_kernel_rules_buf[i] = kernel_rules_buf;
12437 }
12438
12439 /**
12440 * merge rules or automatic rule generator
12441 */
12442
12443 uint kernel_rules_cnt = 0;
12444
12445 kernel_rule_t *kernel_rules_buf = NULL;
12446
12447 if (attack_mode == ATTACK_MODE_STRAIGHT)
12448 {
12449 if (rp_files_cnt)
12450 {
12451 kernel_rules_cnt = 1;
12452
12453 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12454
12455 repeats[0] = kernel_rules_cnt;
12456
12457 for (uint i = 0; i < rp_files_cnt; i++)
12458 {
12459 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12460
12461 repeats[i + 1] = kernel_rules_cnt;
12462 }
12463
12464 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12465
12466 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12467
12468 for (uint i = 0; i < kernel_rules_cnt; i++)
12469 {
12470 uint out_pos = 0;
12471
12472 kernel_rule_t *out = &kernel_rules_buf[i];
12473
12474 for (uint j = 0; j < rp_files_cnt; j++)
12475 {
12476 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12477 uint in_pos;
12478
12479 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12480
12481 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12482 {
12483 if (out_pos == RULES_MAX - 1)
12484 {
12485 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12486
12487 break;
12488 }
12489
12490 out->cmds[out_pos] = in->cmds[in_pos];
12491 }
12492 }
12493 }
12494
12495 local_free (repeats);
12496 }
12497 else if (rp_gen)
12498 {
12499 uint kernel_rules_avail = 0;
12500
12501 while (kernel_rules_cnt < rp_gen)
12502 {
12503 if (kernel_rules_avail == kernel_rules_cnt)
12504 {
12505 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12506
12507 kernel_rules_avail += INCR_RULES;
12508 }
12509
12510 memset (rule_buf, 0, BLOCK_SIZE);
12511
12512 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12513
12514 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12515
12516 kernel_rules_cnt++;
12517 }
12518 }
12519 }
12520
12521 /**
12522 * generate NOP rules
12523 */
12524
12525 if (kernel_rules_cnt == 0)
12526 {
12527 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12528
12529 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12530
12531 kernel_rules_cnt++;
12532 }
12533
12534 data.kernel_rules_cnt = kernel_rules_cnt;
12535 data.kernel_rules_buf = kernel_rules_buf;
12536
12537 /**
12538 * OpenCL platforms: detect
12539 */
12540
12541 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
12542 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
12543
12544 cl_uint platforms_cnt = 0;
12545 cl_uint platform_devices_cnt = 0;
12546
12547 if (keyspace == 0)
12548 {
12549 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12550
12551 if (platforms_cnt == 0)
12552 {
12553 log_error ("ERROR: No OpenCL compatible platform found");
12554
12555 return (-1);
12556 }
12557
12558 if (opencl_platforms_filter != (uint) -1)
12559 {
12560 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
12561
12562 if (opencl_platforms_filter > platform_cnt_mask)
12563 {
12564 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
12565
12566 return (-1);
12567 }
12568 }
12569 }
12570
12571 /**
12572 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12573 */
12574
12575 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12576 {
12577 cl_platform_id platform = platforms[platform_id];
12578
12579 char platform_vendor[INFOSZ] = { 0 };
12580
12581 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12582
12583 #ifdef HAVE_HWMON
12584 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12585 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12586 {
12587 // make sure that we do not directly control the fan for NVidia
12588
12589 gpu_temp_retain = 0;
12590
12591 data.gpu_temp_retain = gpu_temp_retain;
12592 }
12593 #endif // HAVE_NVML || HAVE_NVAPI
12594 #endif
12595 }
12596
12597 /**
12598 * OpenCL devices: simply push all devices from all platforms into the same device array
12599 */
12600
12601 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12602
12603 data.devices_param = devices_param;
12604
12605 uint devices_cnt = 0;
12606
12607 uint devices_active = 0;
12608
12609 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12610 {
12611 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12612
12613 cl_platform_id platform = platforms[platform_id];
12614
12615 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12616
12617 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12618 {
12619 size_t param_value_size = 0;
12620
12621 const uint device_id = devices_cnt;
12622
12623 hc_device_param_t *device_param = &data.devices_param[device_id];
12624
12625 device_param->device = platform_devices[platform_devices_id];
12626
12627 device_param->device_id = device_id;
12628
12629 device_param->platform_devices_id = platform_devices_id;
12630
12631 // device_type
12632
12633 cl_device_type device_type;
12634
12635 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12636
12637 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12638
12639 device_param->device_type = device_type;
12640
12641 // vendor_id
12642
12643 cl_uint vendor_id = 0;
12644
12645 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR_ID, sizeof (vendor_id), &vendor_id, NULL);
12646
12647 device_param->vendor_id = vendor_id;
12648
12649 // device_name
12650
12651 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
12652
12653 char *device_name = (char *) mymalloc (param_value_size);
12654
12655 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
12656
12657 device_param->device_name = device_name;
12658
12659 // tuning db
12660
12661 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
12662
12663 // device_version
12664
12665 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
12666
12667 char *device_version = (char *) mymalloc (param_value_size);
12668
12669 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
12670
12671 device_param->device_version = device_version;
12672
12673 // device_opencl_version
12674
12675 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
12676
12677 char *device_opencl_version = (char *) mymalloc (param_value_size);
12678
12679 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
12680
12681 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
12682
12683 myfree (device_opencl_version);
12684
12685 if (strstr (device_version, "pocl"))
12686 {
12687 // pocl returns the real vendor_id in CL_DEVICE_VENDOR_ID which causes many problems because of hms and missing amd_bfe () etc
12688 // we need to overwrite vendor_id to avoid this. maybe open pocl issue?
12689
12690 cl_uint vendor_id = VENDOR_ID_GENERIC;
12691
12692 device_param->vendor_id = vendor_id;
12693 }
12694
12695 // vector_width
12696
12697 cl_uint vector_width;
12698
12699 if (opencl_vector_width_chgd == 0)
12700 {
12701 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
12702 {
12703 if (opti_type & OPTI_TYPE_USES_BITS_64)
12704 {
12705 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
12706 }
12707 else
12708 {
12709 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12710 }
12711 }
12712 else
12713 {
12714 vector_width = (cl_uint) tuningdb_entry->vector_width;
12715 }
12716 }
12717 else
12718 {
12719 vector_width = opencl_vector_width;
12720 }
12721
12722 if (vector_width > 16) vector_width = 16;
12723
12724 device_param->vector_width = vector_width;
12725
12726 // max_compute_units
12727
12728 cl_uint device_processors;
12729
12730 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12731
12732 device_param->device_processors = device_processors;
12733
12734 // max_mem_alloc_size
12735
12736 cl_ulong device_maxmem_alloc;
12737
12738 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12739
12740 device_param->device_maxmem_alloc = device_maxmem_alloc;
12741
12742 // max_mem_alloc_size
12743
12744 cl_ulong device_global_mem;
12745
12746 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12747
12748 device_param->device_global_mem = device_global_mem;
12749
12750 // max_clock_frequency
12751
12752 cl_uint device_maxclock_frequency;
12753
12754 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12755
12756 device_param->device_maxclock_frequency = device_maxclock_frequency;
12757
12758 // skipped
12759
12760 const u32 skipped1 = ((devices_filter & (1 << device_id)) == 0);
12761 const u32 skipped2 = ((device_types_filter & (device_type)) == 0);
12762
12763 device_param->skipped = (skipped1 || skipped2);
12764
12765 // driver_version
12766 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
12767
12768 char *driver_version = (char *) mymalloc (param_value_size);
12769
12770 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
12771
12772 device_param->driver_version = driver_version;
12773
12774 // device_name_chksum
12775
12776 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12777
12778 #if __x86_64__
12779 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);
12780 #else
12781 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);
12782 #endif
12783
12784 uint device_name_digest[4] = { 0 };
12785
12786 md5_64 ((uint *) device_name_chksum, device_name_digest);
12787
12788 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
12789
12790 device_param->device_name_chksum = device_name_chksum;
12791
12792 // device_processor_cores
12793
12794 if (device_type & CL_DEVICE_TYPE_CPU)
12795 {
12796 cl_uint device_processor_cores = 1;
12797
12798 device_param->device_processor_cores = device_processor_cores;
12799 }
12800
12801 if (device_type & CL_DEVICE_TYPE_GPU)
12802 {
12803 if (vendor_id == VENDOR_ID_AMD)
12804 {
12805 cl_uint device_processor_cores = 0;
12806
12807 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12808
12809 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12810
12811 device_param->device_processor_cores = device_processor_cores;
12812 }
12813 else if (vendor_id == VENDOR_ID_NV)
12814 {
12815 cl_uint kernel_exec_timeout = 0;
12816
12817 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12818
12819 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12820
12821 device_param->kernel_exec_timeout = kernel_exec_timeout;
12822
12823 cl_uint device_processor_cores = 0;
12824
12825 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12826
12827 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12828
12829 device_param->device_processor_cores = device_processor_cores;
12830
12831 cl_uint sm_minor = 0;
12832 cl_uint sm_major = 0;
12833
12834 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12835 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12836
12837 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12838 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12839
12840 device_param->sm_minor = sm_minor;
12841 device_param->sm_major = sm_major;
12842 }
12843 else
12844 {
12845 cl_uint device_processor_cores = 1;
12846
12847 device_param->device_processor_cores = device_processor_cores;
12848 }
12849 }
12850
12851 // display results
12852
12853 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12854 {
12855 if (device_param->skipped == 0)
12856 {
12857 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12858 device_id + 1,
12859 device_name,
12860 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
12861 (unsigned int) (device_global_mem / 1024 / 1024),
12862 (unsigned int) (device_maxclock_frequency),
12863 (unsigned int) device_processors);
12864 }
12865 else
12866 {
12867 log_info ("Device #%u: %s, skipped",
12868 device_id + 1,
12869 device_name);
12870 }
12871 }
12872
12873 // common driver check
12874
12875 if (device_param->skipped == 0)
12876 {
12877 if (strstr (device_version, "pocl"))
12878 {
12879 if (force == 0)
12880 {
12881 log_info ("");
12882 log_info ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
12883 log_info ("You are STRONGLY encouraged not to use it");
12884 log_info ("You can use --force to override this but do not post error reports if you do so");
12885 log_info ("");
12886
12887 return (-1);
12888 }
12889 }
12890
12891 if (device_type & CL_DEVICE_TYPE_GPU)
12892 {
12893 if (vendor_id == VENDOR_ID_NV)
12894 {
12895 if (device_param->kernel_exec_timeout != 0)
12896 {
12897 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);
12898 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12899 }
12900 }
12901 else if (vendor_id == VENDOR_ID_AMD)
12902 {
12903 int catalyst_check = (force == 1) ? 0 : 1;
12904
12905 int catalyst_warn = 0;
12906
12907 int catalyst_broken = 0;
12908
12909 if (catalyst_check == 1)
12910 {
12911 catalyst_warn = 1;
12912
12913 // v14.9 and higher
12914 if (atoi (device_param->driver_version) >= 1573)
12915 {
12916 catalyst_warn = 0;
12917 }
12918
12919 catalyst_check = 0;
12920 }
12921
12922 if (catalyst_broken == 1)
12923 {
12924 log_info ("");
12925 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
12926 log_info ("It will pass over cracked hashes and does not report them as cracked");
12927 log_info ("You are STRONGLY encouraged not to use it");
12928 log_info ("You can use --force to override this but do not post error reports if you do so");
12929 log_info ("");
12930
12931 return (-1);
12932 }
12933
12934 if (catalyst_warn == 1)
12935 {
12936 log_info ("");
12937 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
12938 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
12939 log_info ("See oclHashcat's homepage for official supported catalyst drivers");
12940 #ifdef _WIN
12941 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
12942 #endif
12943 log_info ("You can use --force to override this but do not post error reports if you do so");
12944 log_info ("");
12945
12946 return (-1);
12947 }
12948 }
12949 }
12950
12951 /**
12952 * kernel accel and loops tuning db adjustment
12953 */
12954
12955 device_param->kernel_accel_min = 1;
12956 device_param->kernel_accel_max = 1024;
12957
12958 device_param->kernel_loops_min = 1;
12959 device_param->kernel_loops_max = 1024;
12960
12961 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
12962
12963 if (tuningdb_entry)
12964 {
12965 u32 _kernel_accel = tuningdb_entry->kernel_accel;
12966 u32 _kernel_loops = tuningdb_entry->kernel_loops;
12967
12968 if (_kernel_accel)
12969 {
12970 device_param->kernel_accel_min = _kernel_accel;
12971 device_param->kernel_accel_max = _kernel_accel;
12972 }
12973
12974 if (_kernel_loops)
12975 {
12976 if (workload_profile == 1)
12977 {
12978 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
12979 }
12980 else if (workload_profile == 2)
12981 {
12982 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
12983 }
12984
12985 device_param->kernel_loops_min = _kernel_loops;
12986 device_param->kernel_loops_max = _kernel_loops;
12987 }
12988 }
12989
12990 // commandline parameters overwrite tuningdb entries
12991
12992 if (kernel_accel)
12993 {
12994 device_param->kernel_accel_min = kernel_accel;
12995 device_param->kernel_accel_max = kernel_accel;
12996 }
12997
12998 if (kernel_loops)
12999 {
13000 device_param->kernel_loops_min = kernel_loops;
13001 device_param->kernel_loops_max = kernel_loops;
13002 }
13003
13004 /**
13005 * activate device
13006 */
13007
13008 devices_active++;
13009 }
13010
13011 // next please
13012
13013 devices_cnt++;
13014 }
13015 }
13016
13017 if (keyspace == 0 && devices_active == 0)
13018 {
13019 log_error ("ERROR: No devices found/left");
13020
13021 return (-1);
13022 }
13023
13024 // additional check to see if the user has chosen a device that is not within the range of available devices (i.e. larger than devices_cnt)
13025
13026 if (devices_filter != (uint) -1)
13027 {
13028 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
13029
13030 if (devices_filter > devices_cnt_mask)
13031 {
13032 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
13033
13034 return (-1);
13035 }
13036 }
13037
13038 data.devices_cnt = devices_cnt;
13039
13040 data.devices_active = devices_active;
13041
13042 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13043 {
13044 log_info ("");
13045 }
13046
13047 /**
13048 * HM devices: init
13049 */
13050
13051 #ifdef HAVE_HWMON
13052 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13053 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13054 #endif
13055
13056 #ifdef HAVE_ADL
13057 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13058 #endif
13059
13060 if (gpu_temp_disable == 0)
13061 {
13062 #if defined(WIN) && defined(HAVE_NVAPI)
13063 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13064
13065 if (nvapi_init (nvapi) == 0)
13066 data.hm_nv = nvapi;
13067
13068 if (data.hm_nv)
13069 {
13070 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13071 {
13072 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13073
13074 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13075
13076 int tmp_out = 0;
13077
13078 for (int i = 0; i < tmp_in; i++)
13079 {
13080 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13081 }
13082
13083 for (int i = 0; i < tmp_out; i++)
13084 {
13085 NV_GPU_COOLER_SETTINGS pCoolerSettings;
13086
13087 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
13088
13089 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;
13090 }
13091 }
13092 }
13093 #endif // WIN && HAVE_NVAPI
13094
13095 #if defined(LINUX) && defined(HAVE_NVML)
13096 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13097
13098 if (nvml_init (nvml) == 0)
13099 data.hm_nv = nvml;
13100
13101 if (data.hm_nv)
13102 {
13103 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13104 {
13105 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13106
13107 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13108
13109 int tmp_out = 0;
13110
13111 for (int i = 0; i < tmp_in; i++)
13112 {
13113 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13114 }
13115
13116 for (int i = 0; i < tmp_out; i++)
13117 {
13118 unsigned int speed;
13119
13120 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;
13121 }
13122 }
13123 }
13124 #endif // LINUX && HAVE_NVML
13125
13126 data.hm_amd = NULL;
13127
13128 #ifdef HAVE_ADL
13129 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13130
13131 if (adl_init (adl) == 0)
13132 data.hm_amd = adl;
13133
13134 if (data.hm_amd)
13135 {
13136 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13137 {
13138 // total number of adapters
13139
13140 int hm_adapters_num;
13141
13142 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13143
13144 // adapter info
13145
13146 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13147
13148 if (lpAdapterInfo == NULL) return (-1);
13149
13150 // get a list (of ids of) valid/usable adapters
13151
13152 int num_adl_adapters = 0;
13153
13154 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13155
13156 if (num_adl_adapters > 0)
13157 {
13158 hc_thread_mutex_lock (mux_adl);
13159
13160 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13161
13162 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13163
13164 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13165 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13166
13167 hc_thread_mutex_unlock (mux_adl);
13168 }
13169
13170 myfree (valid_adl_device_list);
13171 myfree (lpAdapterInfo);
13172 }
13173 }
13174 #endif // HAVE_ADL
13175
13176 if (data.hm_amd == NULL && data.hm_nv == NULL)
13177 {
13178 gpu_temp_disable = 1;
13179 }
13180 }
13181
13182 /**
13183 * OpenCL devices: allocate buffer for device specific information
13184 */
13185
13186 #ifdef HAVE_HWMON
13187 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13188
13189 #ifdef HAVE_ADL
13190 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13191
13192 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13193 #endif // ADL
13194 #endif
13195
13196 /**
13197 * enable custom signal handler(s)
13198 */
13199
13200 if (benchmark == 0)
13201 {
13202 hc_signal (sigHandler_default);
13203 }
13204 else
13205 {
13206 hc_signal (sigHandler_benchmark);
13207 }
13208
13209 /**
13210 * User-defined GPU temp handling
13211 */
13212
13213 #ifdef HAVE_HWMON
13214 if (gpu_temp_disable == 1)
13215 {
13216 gpu_temp_abort = 0;
13217 gpu_temp_retain = 0;
13218 }
13219
13220 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13221 {
13222 if (gpu_temp_abort < gpu_temp_retain)
13223 {
13224 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13225
13226 return (-1);
13227 }
13228 }
13229
13230 data.gpu_temp_disable = gpu_temp_disable;
13231 data.gpu_temp_abort = gpu_temp_abort;
13232 data.gpu_temp_retain = gpu_temp_retain;
13233 #endif
13234
13235 /**
13236 * inform the user
13237 */
13238
13239 if (data.quiet == 0)
13240 {
13241 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13242
13243 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);
13244
13245 if (attack_mode == ATTACK_MODE_STRAIGHT)
13246 {
13247 log_info ("Rules: %u", kernel_rules_cnt);
13248 }
13249
13250 if (opti_type)
13251 {
13252 log_info ("Applicable Optimizers:");
13253
13254 for (uint i = 0; i < 32; i++)
13255 {
13256 const uint opti_bit = 1u << i;
13257
13258 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13259 }
13260 }
13261
13262 /**
13263 * Watchdog and Temperature balance
13264 */
13265
13266 #ifdef HAVE_HWMON
13267 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13268 {
13269 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13270 }
13271
13272 if (gpu_temp_abort == 0)
13273 {
13274 log_info ("Watchdog: Temperature abort trigger disabled");
13275 }
13276 else
13277 {
13278 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13279 }
13280
13281 if (gpu_temp_retain == 0)
13282 {
13283 log_info ("Watchdog: Temperature retain trigger disabled");
13284 }
13285 else
13286 {
13287 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13288 }
13289 #endif
13290 }
13291
13292 if (data.quiet == 0) log_info ("");
13293
13294 /**
13295 * HM devices: copy
13296 */
13297
13298 if (gpu_temp_disable == 0)
13299 {
13300 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13301 {
13302 hc_device_param_t *device_param = &data.devices_param[device_id];
13303
13304 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13305
13306 if (device_param->skipped) continue;
13307
13308 const uint platform_devices_id = device_param->platform_devices_id;
13309
13310 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13311 if (device_param->vendor_id == VENDOR_ID_NV)
13312 {
13313 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13314 }
13315 #endif
13316
13317 #ifdef HAVE_ADL
13318 if (device_param->vendor_id == VENDOR_ID_AMD)
13319 {
13320 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13321 }
13322 #endif
13323 }
13324 }
13325
13326 /*
13327 * Temporary fix:
13328 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13329 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13330 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13331 * Driver / ADL bug?
13332 */
13333
13334 #ifdef HAVE_ADL
13335 if (powertune_enable == 1)
13336 {
13337 hc_thread_mutex_lock (mux_adl);
13338
13339 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13340 {
13341 hc_device_param_t *device_param = &data.devices_param[device_id];
13342
13343 if (device_param->skipped) continue;
13344
13345 if (data.hm_device[device_id].od_version == 6)
13346 {
13347 // set powertune value only
13348
13349 int powertune_supported = 0;
13350
13351 int ADL_rc = 0;
13352
13353 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13354 {
13355 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13356
13357 return (-1);
13358 }
13359
13360 if (powertune_supported != 0)
13361 {
13362 // powertune set
13363 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13364
13365 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13366 {
13367 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13368
13369 return (-1);
13370 }
13371
13372 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13373 {
13374 log_error ("ERROR: Failed to set new ADL PowerControl values");
13375
13376 return (-1);
13377 }
13378 }
13379 }
13380 }
13381
13382 hc_thread_mutex_unlock (mux_adl);
13383 }
13384 #endif // HAVE_ADK
13385 #endif // HAVE_HWMON
13386
13387 #ifdef DEBUG
13388 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
13389 #endif
13390
13391 uint kernel_power_all = 0;
13392
13393 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13394 {
13395 /**
13396 * host buffer
13397 */
13398
13399 hc_device_param_t *device_param = &data.devices_param[device_id];
13400
13401 if (device_param->skipped) continue;
13402
13403 /**
13404 * device properties
13405 */
13406
13407 const char *device_name_chksum = device_param->device_name_chksum;
13408 const u32 device_processors = device_param->device_processors;
13409 const u32 device_processor_cores = device_param->device_processor_cores;
13410
13411 /**
13412 * create context for each device
13413 */
13414
13415 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
13416
13417 /**
13418 * create command-queue
13419 */
13420
13421 // not supported with NV
13422 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13423
13424 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
13425
13426 /**
13427 * create input buffers on device : calculate size of fixed memory buffers
13428 */
13429
13430 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13431 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13432
13433 device_param->size_root_css = size_root_css;
13434 device_param->size_markov_css = size_markov_css;
13435
13436 uint size_results = KERNEL_THREADS * sizeof (uint);
13437
13438 device_param->size_results = size_results;
13439
13440 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13441 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13442
13443 uint size_plains = digests_cnt * sizeof (plain_t);
13444 uint size_salts = salts_cnt * sizeof (salt_t);
13445 uint size_esalts = salts_cnt * esalt_size;
13446
13447 device_param->size_plains = size_plains;
13448 device_param->size_digests = size_digests;
13449 device_param->size_shown = size_shown;
13450 device_param->size_salts = size_salts;
13451
13452 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13453 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13454 uint size_tm = 32 * sizeof (bs_word_t);
13455
13456 // scryptV stuff
13457
13458 u64 size_scryptV = 1;
13459
13460 if ((hash_mode == 8900) || (hash_mode == 9300))
13461 {
13462 uint tmto_start = 0;
13463 uint tmto_stop = 10;
13464
13465 if (scrypt_tmto)
13466 {
13467 tmto_start = scrypt_tmto;
13468 }
13469 else
13470 {
13471 // in case the user did not specify the tmto manually
13472 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13473 // but set the lower end only in case the user has a device with too less memory
13474
13475 if (hash_mode == 8900)
13476 {
13477 if (device_param->vendor_id == VENDOR_ID_AMD)
13478 {
13479 tmto_start = 1;
13480 }
13481 else if (device_param->vendor_id == VENDOR_ID_NV)
13482 {
13483 tmto_start = 3;
13484 }
13485 }
13486 else if (hash_mode == 9300)
13487 {
13488 if (device_param->vendor_id == VENDOR_ID_AMD)
13489 {
13490 tmto_start = 3;
13491 }
13492 else if (device_param->vendor_id == VENDOR_ID_NV)
13493 {
13494 tmto_start = 5;
13495 }
13496 }
13497 }
13498
13499 if (quiet == 0) log_info ("");
13500
13501 uint shader_per_mp = 1;
13502
13503 if (device_param->vendor_id == VENDOR_ID_AMD)
13504 {
13505 shader_per_mp = 8;
13506 }
13507 else if (device_param->vendor_id == VENDOR_ID_NV)
13508 {
13509 shader_per_mp = 32;
13510 }
13511
13512 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13513 {
13514 // TODO: in theory the following calculation needs to be done per salt, not global
13515 // we assume all hashes have the same scrypt settings
13516
13517 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13518
13519 size_scryptV /= 1 << tmto;
13520
13521 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13522
13523 if (size_scryptV > device_param->device_maxmem_alloc)
13524 {
13525 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13526
13527 continue;
13528 }
13529
13530 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13531 {
13532 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13533 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13534 }
13535
13536 break;
13537 }
13538
13539 if (data.salts_buf[0].scrypt_phy == 0)
13540 {
13541 log_error ("ERROR: can't allocate enough device memory");
13542
13543 return -1;
13544 }
13545
13546 if (quiet == 0) log_info ("");
13547 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13548 }
13549
13550 /**
13551 * create input buffers on device : calculate size of dynamic size memory buffers
13552 */
13553
13554 uint kernel_threads = KERNEL_THREADS;
13555
13556 // some algorithms need a fixed kernel-threads count (mostly because of shared memory usage)
13557
13558 if (hash_mode == 3200) kernel_threads = 8;
13559 if (hash_mode == 9000) kernel_threads = 8;
13560
13561 /**
13562 * some algorithms need a fixed kernel-loops count
13563 */
13564
13565 if (hash_mode == 1500)
13566 {
13567 const u32 kernel_loops_fixed = 1024;
13568
13569 device_param->kernel_loops_min = kernel_loops_fixed;
13570 device_param->kernel_loops_max = kernel_loops_fixed;
13571 }
13572
13573 if (hash_mode == 3000)
13574 {
13575 const u32 kernel_loops_fixed = 1024;
13576
13577 device_param->kernel_loops_min = kernel_loops_fixed;
13578 device_param->kernel_loops_max = kernel_loops_fixed;
13579 }
13580
13581 if (hash_mode == 8900)
13582 {
13583 const u32 kernel_loops_fixed = 1;
13584
13585 device_param->kernel_loops_min = kernel_loops_fixed;
13586 device_param->kernel_loops_max = kernel_loops_fixed;
13587 }
13588
13589 if (hash_mode == 9300)
13590 {
13591 const u32 kernel_loops_fixed = 1;
13592
13593 device_param->kernel_loops_min = kernel_loops_fixed;
13594 device_param->kernel_loops_max = kernel_loops_fixed;
13595 }
13596
13597 if (hash_mode == 12500)
13598 {
13599 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
13600
13601 device_param->kernel_loops_min = kernel_loops_fixed;
13602 device_param->kernel_loops_max = kernel_loops_fixed;
13603 }
13604
13605 /**
13606 * some algorithms have a maximum kernel-loops count
13607 */
13608
13609 if (attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
13610 {
13611 if (data.salts_buf[0].salt_iter < device_param->kernel_loops_max)
13612 {
13613 device_param->kernel_loops_max = data.salts_buf[0].salt_iter;
13614 }
13615 }
13616
13617 /**
13618 * some algorithms need a special kernel-accel
13619 */
13620
13621 if (hash_mode == 8900)
13622 {
13623 device_param->kernel_accel_min = 1;
13624 device_param->kernel_accel_max = 64;
13625 }
13626
13627 if (hash_mode == 9300)
13628 {
13629 device_param->kernel_accel_min = 1;
13630 device_param->kernel_accel_max = 64;
13631 }
13632
13633 u32 kernel_accel_min = device_param->kernel_accel_min;
13634 u32 kernel_accel_max = device_param->kernel_accel_max;
13635
13636 // find out if we would request too much memory on memory blocks which are based on kernel_accel
13637
13638 uint size_pws = 4;
13639 uint size_tmps = 4;
13640 uint size_hooks = 4;
13641
13642 while (kernel_accel_max >= kernel_accel_min)
13643 {
13644 uint kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
13645
13646 // size_pws
13647
13648 size_pws = kernel_power_max * sizeof (pw_t);
13649
13650 // size_tmps
13651
13652 switch (hash_mode)
13653 {
13654 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
13655 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13656 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13657 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13658 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
13659 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
13660 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
13661 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
13662 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
13663 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
13664 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13665 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13666 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13667 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13668 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13669 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13670 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13671 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13672 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13673 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13674 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13675 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13676 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13677 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
13678 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
13679 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
13680 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
13681 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
13682 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13683 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13684 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
13685 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
13686 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13687 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
13688 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13689 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
13690 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
13691 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13692 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13693 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
13694 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
13695 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
13696 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13697 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
13698 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
13699 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
13700 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
13701 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13702 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
13703 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
13704 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
13705 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
13706 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13707 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
13708 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
13709 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
13710 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
13711 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
13712 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13713 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13714 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13715 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
13716 };
13717
13718 // size_hooks
13719
13720 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13721 {
13722 // none yet
13723 }
13724
13725 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
13726 // if not, decrease amplifier and try again
13727
13728 int skip = 0;
13729
13730 if (size_pws > device_param->device_maxmem_alloc) skip = 1;
13731 if (size_tmps > device_param->device_maxmem_alloc) skip = 1;
13732 if (size_hooks > device_param->device_maxmem_alloc) skip = 1;
13733
13734 if (( bitmap_size
13735 + bitmap_size
13736 + bitmap_size
13737 + bitmap_size
13738 + bitmap_size
13739 + bitmap_size
13740 + bitmap_size
13741 + bitmap_size
13742 + size_bfs
13743 + size_combs
13744 + size_digests
13745 + size_esalts
13746 + size_hooks
13747 + size_markov_css
13748 + size_plains
13749 + size_pws
13750 + size_results
13751 + size_root_css
13752 + size_rules
13753 + size_rules_c
13754 + size_salts
13755 + size_scryptV
13756 + size_shown
13757 + size_tm
13758 + size_tmps) > device_param->device_global_mem) skip = 1;
13759
13760 if (skip == 1)
13761 {
13762 kernel_accel_max--;
13763
13764 continue;
13765 }
13766
13767 break;
13768 }
13769
13770 /*
13771 if (kernel_accel_max == 0)
13772 {
13773 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
13774
13775 return -1;
13776 }
13777 */
13778
13779 device_param->kernel_accel_min = kernel_accel_min;
13780 device_param->kernel_accel_max = kernel_accel_max;
13781
13782 /*
13783 if (kernel_accel_max < kernel_accel)
13784 {
13785 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
13786
13787 device_param->kernel_accel = kernel_accel_max;
13788 }
13789 */
13790
13791 device_param->size_bfs = size_bfs;
13792 device_param->size_combs = size_combs;
13793 device_param->size_rules = size_rules;
13794 device_param->size_rules_c = size_rules_c;
13795 device_param->size_pws = size_pws;
13796 device_param->size_tmps = size_tmps;
13797 device_param->size_hooks = size_hooks;
13798
13799 // do not confuse kernel_accel_max with kernel_accel here
13800
13801 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
13802
13803 device_param->kernel_threads = kernel_threads;
13804 device_param->kernel_power_user = kernel_power;
13805
13806 kernel_power_all += kernel_power;
13807
13808 /**
13809 * default building options
13810 */
13811
13812 char build_opts[1024] = { 0 };
13813
13814 // we don't have sm_* on vendors not NV but it doesn't matter
13815
13816 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);
13817
13818 /**
13819 * main kernel
13820 */
13821
13822 {
13823 /**
13824 * kernel source filename
13825 */
13826
13827 char source_file[256] = { 0 };
13828
13829 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13830
13831 struct stat sst;
13832
13833 if (stat (source_file, &sst) == -1)
13834 {
13835 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13836
13837 return -1;
13838 }
13839
13840 /**
13841 * kernel cached filename
13842 */
13843
13844 char cached_file[256] = { 0 };
13845
13846 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
13847
13848 int cached = 1;
13849
13850 struct stat cst;
13851
13852 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
13853 {
13854 cached = 0;
13855 }
13856
13857 /**
13858 * kernel compile or load
13859 */
13860
13861 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13862
13863 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13864
13865 if (force_jit_compilation == -1)
13866 {
13867 if (cached == 0)
13868 {
13869 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13870
13871 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13872
13873 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13874
13875 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
13876
13877 #ifdef DEBUG
13878 size_t build_log_size = 0;
13879
13880 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
13881
13882 if (build_log_size > 1)
13883 {
13884 char *build_log = (char *) malloc (build_log_size + 1);
13885
13886 memset (build_log, 0, build_log_size + 1);
13887
13888 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
13889
13890 puts (build_log);
13891
13892 free (build_log);
13893 }
13894 #endif
13895
13896 if (rc != 0)
13897 {
13898 device_param->skipped = true;
13899 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13900 continue;
13901 }
13902
13903 size_t binary_size;
13904
13905 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13906
13907 u8 *binary = (u8 *) mymalloc (binary_size);
13908
13909 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13910
13911 writeProgramBin (cached_file, binary, binary_size);
13912
13913 local_free (binary);
13914 }
13915 else
13916 {
13917 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13918
13919 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13920
13921 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13922
13923 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
13924 }
13925 }
13926 else
13927 {
13928 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13929
13930 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13931
13932 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13933
13934 char build_opts_update[1024] = { 0 };
13935
13936 if (force_jit_compilation == 1500)
13937 {
13938 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13939 }
13940 else if (force_jit_compilation == 8900)
13941 {
13942 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);
13943 }
13944 else
13945 {
13946 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
13947 }
13948
13949 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
13950
13951 #ifdef DEBUG
13952 size_t build_log_size = 0;
13953
13954 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
13955
13956 if (build_log_size > 1)
13957 {
13958 char *build_log = (char *) malloc (build_log_size + 1);
13959
13960 memset (build_log, 0, build_log_size + 1);
13961
13962 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
13963
13964 puts (build_log);
13965
13966 free (build_log);
13967 }
13968 #endif
13969
13970 if (rc != 0)
13971 {
13972 device_param->skipped = true;
13973
13974 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13975 }
13976 }
13977
13978 local_free (kernel_lengths);
13979 local_free (kernel_sources[0]);
13980 local_free (kernel_sources);
13981 }
13982
13983 /**
13984 * word generator kernel
13985 */
13986
13987 if (attack_mode != ATTACK_MODE_STRAIGHT)
13988 {
13989 /**
13990 * kernel mp source filename
13991 */
13992
13993 char source_file[256] = { 0 };
13994
13995 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
13996
13997 struct stat sst;
13998
13999 if (stat (source_file, &sst) == -1)
14000 {
14001 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14002
14003 return -1;
14004 }
14005
14006 /**
14007 * kernel mp cached filename
14008 */
14009
14010 char cached_file[256] = { 0 };
14011
14012 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
14013
14014 int cached = 1;
14015
14016 struct stat cst;
14017
14018 if (stat (cached_file, &cst) == -1)
14019 {
14020 cached = 0;
14021 }
14022
14023 /**
14024 * kernel compile or load
14025 */
14026
14027 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14028
14029 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14030
14031 if (cached == 0)
14032 {
14033 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14034
14035 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14036
14037 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14038
14039 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
14040
14041 if (rc != 0)
14042 {
14043 device_param->skipped = true;
14044 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14045 continue;
14046 }
14047
14048 size_t binary_size;
14049
14050 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14051
14052 u8 *binary = (u8 *) mymalloc (binary_size);
14053
14054 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14055
14056 writeProgramBin (cached_file, binary, binary_size);
14057
14058 local_free (binary);
14059 }
14060 else
14061 {
14062 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14063
14064 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14065
14066 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14067
14068 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
14069 }
14070
14071 local_free (kernel_lengths);
14072 local_free (kernel_sources[0]);
14073 local_free (kernel_sources);
14074 }
14075
14076 /**
14077 * amplifier kernel
14078 */
14079
14080 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14081 {
14082
14083 }
14084 else
14085 {
14086 /**
14087 * kernel amp source filename
14088 */
14089
14090 char source_file[256] = { 0 };
14091
14092 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
14093
14094 struct stat sst;
14095
14096 if (stat (source_file, &sst) == -1)
14097 {
14098 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14099
14100 return -1;
14101 }
14102
14103 /**
14104 * kernel amp cached filename
14105 */
14106
14107 char cached_file[256] = { 0 };
14108
14109 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
14110
14111 int cached = 1;
14112
14113 struct stat cst;
14114
14115 if (stat (cached_file, &cst) == -1)
14116 {
14117 cached = 0;
14118 }
14119
14120 /**
14121 * kernel compile or load
14122 */
14123
14124 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14125
14126 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14127
14128 if (cached == 0)
14129 {
14130 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14131
14132 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14133
14134 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14135
14136 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
14137
14138 if (rc != 0)
14139 {
14140 device_param->skipped = true;
14141 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14142 continue;
14143 }
14144
14145 size_t binary_size;
14146
14147 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14148
14149 u8 *binary = (u8 *) mymalloc (binary_size);
14150
14151 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14152
14153 writeProgramBin (cached_file, binary, binary_size);
14154
14155 local_free (binary);
14156 }
14157 else
14158 {
14159 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14160
14161 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14162
14163 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14164
14165 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
14166 }
14167
14168 local_free (kernel_lengths);
14169 local_free (kernel_sources[0]);
14170 local_free (kernel_sources);
14171 }
14172
14173 // some algorithm collide too fast, make that impossible
14174
14175 if (benchmark == 1)
14176 {
14177 ((uint *) digests_buf)[0] = -1;
14178 ((uint *) digests_buf)[1] = -1;
14179 ((uint *) digests_buf)[2] = -1;
14180 ((uint *) digests_buf)[3] = -1;
14181 }
14182
14183 /**
14184 * global buffers
14185 */
14186
14187 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14188 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14189 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
14190 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
14191 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14192 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14193 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14194 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14195 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14196 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14197 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14198 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14199 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
14200 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
14201 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
14202 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
14203 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
14204 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
14205
14206 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);
14207 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);
14208 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);
14209 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);
14210 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);
14211 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);
14212 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);
14213 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);
14214 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
14215 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
14216 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
14217
14218 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
14219 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
14220 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
14221 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
14222 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
14223 run_kernel_bzero (device_param, device_param->d_result, size_results);
14224
14225 /**
14226 * special buffers
14227 */
14228
14229 if (attack_kern == ATTACK_KERN_STRAIGHT)
14230 {
14231 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
14232 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
14233
14234 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
14235
14236 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
14237 }
14238 else if (attack_kern == ATTACK_KERN_COMBI)
14239 {
14240 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14241 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14242 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14243 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14244
14245 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
14246 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
14247 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14248 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14249 }
14250 else if (attack_kern == ATTACK_KERN_BF)
14251 {
14252 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14253 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14254 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
14255 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14256 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14257
14258 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
14259 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
14260 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
14261 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14262 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14263 }
14264
14265 if (size_esalts)
14266 {
14267 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
14268
14269 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
14270 }
14271
14272 /**
14273 * main host data
14274 */
14275
14276 uint *result = (uint *) mymalloc (size_results);
14277
14278 device_param->result = result;
14279
14280 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
14281
14282 device_param->pws_buf = pws_buf;
14283
14284 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
14285
14286 device_param->combs_buf = combs_buf;
14287
14288 void *hooks_buf = mymalloc (size_hooks);
14289
14290 device_param->hooks_buf = hooks_buf;
14291
14292 /**
14293 * kernel args
14294 */
14295
14296 device_param->kernel_params_buf32[21] = bitmap_mask;
14297 device_param->kernel_params_buf32[22] = bitmap_shift1;
14298 device_param->kernel_params_buf32[23] = bitmap_shift2;
14299 device_param->kernel_params_buf32[24] = 0; // salt_pos
14300 device_param->kernel_params_buf32[25] = 0; // loop_pos
14301 device_param->kernel_params_buf32[26] = 0; // loop_cnt
14302 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
14303 device_param->kernel_params_buf32[28] = 0; // digests_cnt
14304 device_param->kernel_params_buf32[29] = 0; // digests_offset
14305 device_param->kernel_params_buf32[30] = 0; // combs_mode
14306 device_param->kernel_params_buf32[31] = 0; // gid_max
14307
14308 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14309 ? &device_param->d_pws_buf
14310 : &device_param->d_pws_amp_buf;
14311 device_param->kernel_params[ 1] = &device_param->d_rules_c;
14312 device_param->kernel_params[ 2] = &device_param->d_combs_c;
14313 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
14314 device_param->kernel_params[ 4] = &device_param->d_tmps;
14315 device_param->kernel_params[ 5] = &device_param->d_hooks;
14316 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
14317 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
14318 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
14319 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
14320 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
14321 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
14322 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
14323 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
14324 device_param->kernel_params[14] = &device_param->d_plain_bufs;
14325 device_param->kernel_params[15] = &device_param->d_digests_buf;
14326 device_param->kernel_params[16] = &device_param->d_digests_shown;
14327 device_param->kernel_params[17] = &device_param->d_salt_bufs;
14328 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
14329 device_param->kernel_params[19] = &device_param->d_result;
14330 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
14331 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
14332 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
14333 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
14334 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
14335 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
14336 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
14337 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
14338 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
14339 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
14340 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
14341 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
14342
14343 device_param->kernel_params_mp_buf64[3] = 0;
14344 device_param->kernel_params_mp_buf32[4] = 0;
14345 device_param->kernel_params_mp_buf32[5] = 0;
14346 device_param->kernel_params_mp_buf32[6] = 0;
14347 device_param->kernel_params_mp_buf32[7] = 0;
14348 device_param->kernel_params_mp_buf32[8] = 0;
14349
14350 device_param->kernel_params_mp[0] = NULL;
14351 device_param->kernel_params_mp[1] = NULL;
14352 device_param->kernel_params_mp[2] = NULL;
14353 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
14354 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
14355 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
14356 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
14357 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
14358 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
14359
14360 device_param->kernel_params_mp_l_buf64[3] = 0;
14361 device_param->kernel_params_mp_l_buf32[4] = 0;
14362 device_param->kernel_params_mp_l_buf32[5] = 0;
14363 device_param->kernel_params_mp_l_buf32[6] = 0;
14364 device_param->kernel_params_mp_l_buf32[7] = 0;
14365 device_param->kernel_params_mp_l_buf32[8] = 0;
14366 device_param->kernel_params_mp_l_buf32[9] = 0;
14367
14368 device_param->kernel_params_mp_l[0] = NULL;
14369 device_param->kernel_params_mp_l[1] = NULL;
14370 device_param->kernel_params_mp_l[2] = NULL;
14371 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14372 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14373 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14374 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14375 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14376 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14377 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14378
14379 device_param->kernel_params_mp_r_buf64[3] = 0;
14380 device_param->kernel_params_mp_r_buf32[4] = 0;
14381 device_param->kernel_params_mp_r_buf32[5] = 0;
14382 device_param->kernel_params_mp_r_buf32[6] = 0;
14383 device_param->kernel_params_mp_r_buf32[7] = 0;
14384 device_param->kernel_params_mp_r_buf32[8] = 0;
14385
14386 device_param->kernel_params_mp_r[0] = NULL;
14387 device_param->kernel_params_mp_r[1] = NULL;
14388 device_param->kernel_params_mp_r[2] = NULL;
14389 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14390 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14391 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14392 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14393 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14394 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14395
14396 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14397 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14398
14399 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14400 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14401 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14402 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14403 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14404 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14405 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14406
14407 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14408 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14409
14410 /**
14411 * kernel name
14412 */
14413
14414 char kernel_name[64] = { 0 };
14415
14416 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14417 {
14418 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14419 {
14420 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14421
14422 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14423
14424 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14425
14426 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14427
14428 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14429
14430 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14431 }
14432 else
14433 {
14434 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14435
14436 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14437
14438 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14439
14440 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14441
14442 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14443
14444 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14445 }
14446
14447 if (data.attack_mode == ATTACK_MODE_BF)
14448 {
14449 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14450 {
14451 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14452
14453 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14454 }
14455 }
14456 }
14457 else
14458 {
14459 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14460
14461 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14462
14463 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14464
14465 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14466
14467 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14468
14469 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14470
14471 if (opts_type & OPTS_TYPE_HOOK12)
14472 {
14473 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14474
14475 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14476 }
14477
14478 if (opts_type & OPTS_TYPE_HOOK23)
14479 {
14480 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14481
14482 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14483 }
14484 }
14485
14486 for (uint i = 0; i <= 20; i++)
14487 {
14488 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14489 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14490 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14491
14492 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14493 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14494 }
14495
14496 for (uint i = 21; i <= 31; i++)
14497 {
14498 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14499 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14500 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14501
14502 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14503 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14504 }
14505
14506 if (attack_mode == ATTACK_MODE_BF)
14507 {
14508 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
14509 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
14510
14511 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14512 {
14513 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14514 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14515 }
14516 }
14517 else if (attack_mode == ATTACK_MODE_HYBRID1)
14518 {
14519 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14520 }
14521 else if (attack_mode == ATTACK_MODE_HYBRID2)
14522 {
14523 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14524 }
14525
14526 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14527 {
14528 // nothing to do
14529 }
14530 else
14531 {
14532 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
14533 }
14534
14535 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14536 {
14537 // nothing to do
14538 }
14539 else
14540 {
14541 for (uint i = 0; i < 5; i++)
14542 {
14543 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14544 }
14545
14546 for (uint i = 5; i < 7; i++)
14547 {
14548 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14549 }
14550 }
14551
14552 /**
14553 * Store initial fanspeed if gpu_temp_retain is enabled
14554 */
14555
14556 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
14557 int gpu_temp_retain_set = 0;
14558
14559 if (gpu_temp_disable == 0)
14560 {
14561 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14562 {
14563 hc_thread_mutex_lock (mux_adl);
14564
14565 if (data.hm_device[device_id].fan_supported == 1)
14566 {
14567 if (gpu_temp_retain_chgd == 0)
14568 {
14569 uint cur_temp = 0;
14570 uint default_temp = 0;
14571
14572 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);
14573
14574 if (ADL_rc == ADL_OK)
14575 {
14576 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14577
14578 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14579
14580 // special case with multi gpu setups: always use minimum retain
14581
14582 if (gpu_temp_retain_set == 0)
14583 {
14584 gpu_temp_retain = gpu_temp_retain_target;
14585 gpu_temp_retain_set = 1;
14586 }
14587 else
14588 {
14589 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14590 }
14591
14592 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14593 }
14594 }
14595
14596 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14597
14598 temp_retain_fanspeed_value[device_id] = fan_speed;
14599
14600 if (fan_speed == -1)
14601 {
14602 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14603
14604 temp_retain_fanspeed_value[device_id] = 0;
14605 }
14606 }
14607
14608 hc_thread_mutex_unlock (mux_adl);
14609 }
14610 }
14611
14612 /**
14613 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14614 */
14615
14616 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14617 {
14618 hc_thread_mutex_lock (mux_adl);
14619
14620 if (data.hm_device[device_id].od_version == 6)
14621 {
14622 int ADL_rc;
14623
14624 // check powertune capabilities first, if not available then skip device
14625
14626 int powertune_supported = 0;
14627
14628 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14629 {
14630 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14631
14632 return (-1);
14633 }
14634
14635 if (powertune_supported != 0)
14636 {
14637 // powercontrol settings
14638
14639 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14640
14641 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14642 {
14643 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14644 }
14645
14646 if (ADL_rc != ADL_OK)
14647 {
14648 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14649
14650 return (-1);
14651 }
14652
14653 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14654 {
14655 log_error ("ERROR: Failed to set new ADL PowerControl values");
14656
14657 return (-1);
14658 }
14659
14660 // clocks
14661
14662 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14663
14664 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14665
14666 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)
14667 {
14668 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14669
14670 return (-1);
14671 }
14672
14673 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14674
14675 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14676
14677 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14678 {
14679 log_error ("ERROR: Failed to get ADL device capabilities");
14680
14681 return (-1);
14682 }
14683
14684 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14685 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14686
14687 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14688 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14689
14690 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14691 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14692
14693 // warning if profile has too low max values
14694
14695 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14696 {
14697 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14698 }
14699
14700 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14701 {
14702 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14703 }
14704
14705 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14706
14707 performance_state->iNumberOfPerformanceLevels = 2;
14708
14709 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14710 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14711 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14712 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14713
14714 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)
14715 {
14716 log_info ("ERROR: Failed to set ADL performance state");
14717
14718 return (-1);
14719 }
14720
14721 local_free (performance_state);
14722 }
14723 }
14724
14725 hc_thread_mutex_unlock (mux_adl);
14726 }
14727 #endif // HAVE_HWMON && HAVE_ADL
14728 }
14729
14730 data.kernel_power_all = kernel_power_all;
14731
14732 if (data.quiet == 0) log_info ("");
14733
14734 /**
14735 * Inform user which algorithm is checked and at which workload setting
14736 */
14737
14738 if (benchmark == 1)
14739 {
14740 quiet = 0;
14741
14742 data.quiet = quiet;
14743
14744 char *hash_type = strhashtype (data.hash_mode); // not a bug
14745
14746 log_info ("Hashtype: %s", hash_type);
14747 log_info ("");
14748 }
14749
14750 /**
14751 * keep track of the progress
14752 */
14753
14754 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14755 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14756 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14757
14758 /**
14759 * open filehandles
14760 */
14761
14762 #if _WIN
14763 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14764 {
14765 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14766
14767 return (-1);
14768 }
14769
14770 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14771 {
14772 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14773
14774 return (-1);
14775 }
14776
14777 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14778 {
14779 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14780
14781 return (-1);
14782 }
14783 #endif
14784
14785 /**
14786 * dictionary pad
14787 */
14788
14789 segment_size *= (1024 * 1024);
14790
14791 data.segment_size = segment_size;
14792
14793 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14794
14795 wl_data->buf = (char *) mymalloc (segment_size);
14796 wl_data->avail = segment_size;
14797 wl_data->incr = segment_size;
14798 wl_data->cnt = 0;
14799 wl_data->pos = 0;
14800
14801 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14802
14803 data.wordlist_mode = wordlist_mode;
14804
14805 cs_t *css_buf = NULL;
14806 uint css_cnt = 0;
14807 uint dictcnt = 0;
14808 uint maskcnt = 1;
14809 char **masks = NULL;
14810 char **dictfiles = NULL;
14811
14812 uint mask_from_file = 0;
14813
14814 if (attack_mode == ATTACK_MODE_STRAIGHT)
14815 {
14816 if (wordlist_mode == WL_MODE_FILE)
14817 {
14818 int wls_left = myargc - (optind + 1);
14819
14820 for (int i = 0; i < wls_left; i++)
14821 {
14822 char *l0_filename = myargv[optind + 1 + i];
14823
14824 struct stat l0_stat;
14825
14826 if (stat (l0_filename, &l0_stat) == -1)
14827 {
14828 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14829
14830 return (-1);
14831 }
14832
14833 uint is_dir = S_ISDIR (l0_stat.st_mode);
14834
14835 if (is_dir == 0)
14836 {
14837 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14838
14839 dictcnt++;
14840
14841 dictfiles[dictcnt - 1] = l0_filename;
14842 }
14843 else
14844 {
14845 // do not allow --keyspace w/ a directory
14846
14847 if (keyspace == 1)
14848 {
14849 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14850
14851 return (-1);
14852 }
14853
14854 char **dictionary_files = NULL;
14855
14856 dictionary_files = scan_directory (l0_filename);
14857
14858 if (dictionary_files != NULL)
14859 {
14860 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14861
14862 for (int d = 0; dictionary_files[d] != NULL; d++)
14863 {
14864 char *l1_filename = dictionary_files[d];
14865
14866 struct stat l1_stat;
14867
14868 if (stat (l1_filename, &l1_stat) == -1)
14869 {
14870 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14871
14872 return (-1);
14873 }
14874
14875 if (S_ISREG (l1_stat.st_mode))
14876 {
14877 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14878
14879 dictcnt++;
14880
14881 dictfiles[dictcnt - 1] = strdup (l1_filename);
14882 }
14883 }
14884 }
14885
14886 local_free (dictionary_files);
14887 }
14888 }
14889
14890 if (dictcnt < 1)
14891 {
14892 log_error ("ERROR: No usable dictionary file found.");
14893
14894 return (-1);
14895 }
14896 }
14897 else if (wordlist_mode == WL_MODE_STDIN)
14898 {
14899 dictcnt = 1;
14900 }
14901 }
14902 else if (attack_mode == ATTACK_MODE_COMBI)
14903 {
14904 // display
14905
14906 char *dictfile1 = myargv[optind + 1 + 0];
14907 char *dictfile2 = myargv[optind + 1 + 1];
14908
14909 // find the bigger dictionary and use as base
14910
14911 FILE *fp1 = NULL;
14912 FILE *fp2 = NULL;
14913
14914 struct stat tmp_stat;
14915
14916 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14917 {
14918 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14919
14920 return (-1);
14921 }
14922
14923 if (stat (dictfile1, &tmp_stat) == -1)
14924 {
14925 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14926
14927 fclose (fp1);
14928
14929 return (-1);
14930 }
14931
14932 if (S_ISDIR (tmp_stat.st_mode))
14933 {
14934 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14935
14936 fclose (fp1);
14937
14938 return (-1);
14939 }
14940
14941 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14942 {
14943 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14944
14945 fclose (fp1);
14946
14947 return (-1);
14948 }
14949
14950 if (stat (dictfile2, &tmp_stat) == -1)
14951 {
14952 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14953
14954 fclose (fp1);
14955 fclose (fp2);
14956
14957 return (-1);
14958 }
14959
14960 if (S_ISDIR (tmp_stat.st_mode))
14961 {
14962 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
14963
14964 fclose (fp1);
14965 fclose (fp2);
14966
14967 return (-1);
14968 }
14969
14970 data.combs_cnt = 1;
14971
14972 data.quiet = 1;
14973
14974 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
14975
14976 data.quiet = quiet;
14977
14978 if (words1_cnt == 0)
14979 {
14980 log_error ("ERROR: %s: empty file", dictfile1);
14981
14982 fclose (fp1);
14983 fclose (fp2);
14984
14985 return (-1);
14986 }
14987
14988 data.combs_cnt = 1;
14989
14990 data.quiet = 1;
14991
14992 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
14993
14994 data.quiet = quiet;
14995
14996 if (words2_cnt == 0)
14997 {
14998 log_error ("ERROR: %s: empty file", dictfile2);
14999
15000 fclose (fp1);
15001 fclose (fp2);
15002
15003 return (-1);
15004 }
15005
15006 fclose (fp1);
15007 fclose (fp2);
15008
15009 data.dictfile = dictfile1;
15010 data.dictfile2 = dictfile2;
15011
15012 if (words1_cnt >= words2_cnt)
15013 {
15014 data.combs_cnt = words2_cnt;
15015 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15016
15017 dictfiles = &data.dictfile;
15018
15019 dictcnt = 1;
15020 }
15021 else
15022 {
15023 data.combs_cnt = words1_cnt;
15024 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15025
15026 dictfiles = &data.dictfile2;
15027
15028 dictcnt = 1;
15029
15030 // we also have to switch wordlist related rules!
15031
15032 char *tmpc = data.rule_buf_l;
15033
15034 data.rule_buf_l = data.rule_buf_r;
15035 data.rule_buf_r = tmpc;
15036
15037 int tmpi = data.rule_len_l;
15038
15039 data.rule_len_l = data.rule_len_r;
15040 data.rule_len_r = tmpi;
15041 }
15042 }
15043 else if (attack_mode == ATTACK_MODE_BF)
15044 {
15045 char *mask = NULL;
15046
15047 maskcnt = 0;
15048
15049 if (benchmark == 0)
15050 {
15051 mask = myargv[optind + 1];
15052
15053 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
15054
15055 if ((optind + 2) <= myargc)
15056 {
15057 struct stat file_stat;
15058
15059 if (stat (mask, &file_stat) == -1)
15060 {
15061 maskcnt = 1;
15062
15063 masks[maskcnt - 1] = mystrdup (mask);
15064 }
15065 else
15066 {
15067 int wls_left = myargc - (optind + 1);
15068
15069 uint masks_avail = INCR_MASKS;
15070
15071 for (int i = 0; i < wls_left; i++)
15072 {
15073 if (i != 0)
15074 {
15075 mask = myargv[optind + 1 + i];
15076
15077 if (stat (mask, &file_stat) == -1)
15078 {
15079 log_error ("ERROR: %s: %s", mask, strerror (errno));
15080
15081 return (-1);
15082 }
15083 }
15084
15085 uint is_file = S_ISREG (file_stat.st_mode);
15086
15087 if (is_file == 1)
15088 {
15089 FILE *mask_fp;
15090
15091 if ((mask_fp = fopen (mask, "r")) == NULL)
15092 {
15093 log_error ("ERROR: %s: %s", mask, strerror (errno));
15094
15095 return (-1);
15096 }
15097
15098 char line_buf[BUFSIZ] = { 0 };
15099
15100 while (!feof (mask_fp))
15101 {
15102 memset (line_buf, 0, BUFSIZ);
15103
15104 int line_len = fgetl (mask_fp, line_buf);
15105
15106 if (line_len == 0) continue;
15107
15108 if (line_buf[0] == '#') continue;
15109
15110 if (masks_avail == maskcnt)
15111 {
15112 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15113
15114 masks_avail += INCR_MASKS;
15115 }
15116
15117 masks[maskcnt] = mystrdup (line_buf);
15118
15119 maskcnt++;
15120 }
15121
15122 fclose (mask_fp);
15123 }
15124 else
15125 {
15126 log_error ("ERROR: %s: unsupported file-type", mask);
15127
15128 return (-1);
15129 }
15130 }
15131
15132 mask_from_file = 1;
15133 }
15134 }
15135 else
15136 {
15137 custom_charset_1 = (char *) "?l?d?u";
15138 custom_charset_2 = (char *) "?l?d";
15139 custom_charset_3 = (char *) "?l?d*!$@_";
15140
15141 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15142 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15143 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15144
15145 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
15146
15147 wordlist_mode = WL_MODE_MASK;
15148
15149 data.wordlist_mode = wordlist_mode;
15150
15151 increment = 1;
15152
15153 maskcnt = 1;
15154 }
15155 }
15156 else
15157 {
15158 /**
15159 * generate full masks and charsets
15160 */
15161
15162 masks = (char **) mymalloc (sizeof (char *));
15163
15164 switch (hash_mode)
15165 {
15166 case 1731: pw_min = 5;
15167 pw_max = 5;
15168 mask = mystrdup ("?b?b?b?b?b");
15169 break;
15170 case 12500: pw_min = 5;
15171 pw_max = 5;
15172 mask = mystrdup ("?b?b?b?b?b");
15173 break;
15174 default: pw_min = 7;
15175 pw_max = 7;
15176 mask = mystrdup ("?b?b?b?b?b?b?b");
15177 break;
15178 }
15179
15180 maskcnt = 1;
15181
15182 masks[maskcnt - 1] = mystrdup (mask);
15183
15184 wordlist_mode = WL_MODE_MASK;
15185
15186 data.wordlist_mode = wordlist_mode;
15187
15188 increment = 1;
15189 }
15190
15191 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
15192
15193 if (increment)
15194 {
15195 if (increment_min > pw_min) pw_min = increment_min;
15196
15197 if (increment_max < pw_max) pw_max = increment_max;
15198 }
15199 }
15200 else if (attack_mode == ATTACK_MODE_HYBRID1)
15201 {
15202 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15203
15204 // display
15205
15206 char *mask = myargv[myargc - 1];
15207
15208 maskcnt = 0;
15209
15210 masks = (char **) mymalloc (1 * sizeof (char *));
15211
15212 // mod
15213
15214 struct stat file_stat;
15215
15216 if (stat (mask, &file_stat) == -1)
15217 {
15218 maskcnt = 1;
15219
15220 masks[maskcnt - 1] = mystrdup (mask);
15221 }
15222 else
15223 {
15224 uint is_file = S_ISREG (file_stat.st_mode);
15225
15226 if (is_file == 1)
15227 {
15228 FILE *mask_fp;
15229
15230 if ((mask_fp = fopen (mask, "r")) == NULL)
15231 {
15232 log_error ("ERROR: %s: %s", mask, strerror (errno));
15233
15234 return (-1);
15235 }
15236
15237 char line_buf[BUFSIZ] = { 0 };
15238
15239 uint masks_avail = 1;
15240
15241 while (!feof (mask_fp))
15242 {
15243 memset (line_buf, 0, BUFSIZ);
15244
15245 int line_len = fgetl (mask_fp, line_buf);
15246
15247 if (line_len == 0) continue;
15248
15249 if (line_buf[0] == '#') continue;
15250
15251 if (masks_avail == maskcnt)
15252 {
15253 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15254
15255 masks_avail += INCR_MASKS;
15256 }
15257
15258 masks[maskcnt] = mystrdup (line_buf);
15259
15260 maskcnt++;
15261 }
15262
15263 fclose (mask_fp);
15264
15265 mask_from_file = 1;
15266 }
15267 else
15268 {
15269 maskcnt = 1;
15270
15271 masks[maskcnt - 1] = mystrdup (mask);
15272 }
15273 }
15274
15275 // base
15276
15277 int wls_left = myargc - (optind + 2);
15278
15279 for (int i = 0; i < wls_left; i++)
15280 {
15281 char *filename = myargv[optind + 1 + i];
15282
15283 struct stat file_stat;
15284
15285 if (stat (filename, &file_stat) == -1)
15286 {
15287 log_error ("ERROR: %s: %s", filename, strerror (errno));
15288
15289 return (-1);
15290 }
15291
15292 uint is_dir = S_ISDIR (file_stat.st_mode);
15293
15294 if (is_dir == 0)
15295 {
15296 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15297
15298 dictcnt++;
15299
15300 dictfiles[dictcnt - 1] = filename;
15301 }
15302 else
15303 {
15304 // do not allow --keyspace w/ a directory
15305
15306 if (keyspace == 1)
15307 {
15308 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15309
15310 return (-1);
15311 }
15312
15313 char **dictionary_files = NULL;
15314
15315 dictionary_files = scan_directory (filename);
15316
15317 if (dictionary_files != NULL)
15318 {
15319 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15320
15321 for (int d = 0; dictionary_files[d] != NULL; d++)
15322 {
15323 char *l1_filename = dictionary_files[d];
15324
15325 struct stat l1_stat;
15326
15327 if (stat (l1_filename, &l1_stat) == -1)
15328 {
15329 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15330
15331 return (-1);
15332 }
15333
15334 if (S_ISREG (l1_stat.st_mode))
15335 {
15336 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15337
15338 dictcnt++;
15339
15340 dictfiles[dictcnt - 1] = strdup (l1_filename);
15341 }
15342 }
15343 }
15344
15345 local_free (dictionary_files);
15346 }
15347 }
15348
15349 if (dictcnt < 1)
15350 {
15351 log_error ("ERROR: No usable dictionary file found.");
15352
15353 return (-1);
15354 }
15355
15356 if (increment)
15357 {
15358 maskcnt = 0;
15359
15360 uint mask_min = increment_min; // we can't reject smaller masks here
15361 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15362
15363 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15364 {
15365 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15366
15367 if (cur_mask == NULL) break;
15368
15369 masks[maskcnt] = cur_mask;
15370
15371 maskcnt++;
15372
15373 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15374 }
15375 }
15376 }
15377 else if (attack_mode == ATTACK_MODE_HYBRID2)
15378 {
15379 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15380
15381 // display
15382
15383 char *mask = myargv[optind + 1 + 0];
15384
15385 maskcnt = 0;
15386
15387 masks = (char **) mymalloc (1 * sizeof (char *));
15388
15389 // mod
15390
15391 struct stat file_stat;
15392
15393 if (stat (mask, &file_stat) == -1)
15394 {
15395 maskcnt = 1;
15396
15397 masks[maskcnt - 1] = mystrdup (mask);
15398 }
15399 else
15400 {
15401 uint is_file = S_ISREG (file_stat.st_mode);
15402
15403 if (is_file == 1)
15404 {
15405 FILE *mask_fp;
15406
15407 if ((mask_fp = fopen (mask, "r")) == NULL)
15408 {
15409 log_error ("ERROR: %s: %s", mask, strerror (errno));
15410
15411 return (-1);
15412 }
15413
15414 char line_buf[BUFSIZ] = { 0 };
15415
15416 uint masks_avail = 1;
15417
15418 while (!feof (mask_fp))
15419 {
15420 memset (line_buf, 0, BUFSIZ);
15421
15422 int line_len = fgetl (mask_fp, line_buf);
15423
15424 if (line_len == 0) continue;
15425
15426 if (line_buf[0] == '#') continue;
15427
15428 if (masks_avail == maskcnt)
15429 {
15430 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15431
15432 masks_avail += INCR_MASKS;
15433 }
15434
15435 masks[maskcnt] = mystrdup (line_buf);
15436
15437 maskcnt++;
15438 }
15439
15440 fclose (mask_fp);
15441
15442 mask_from_file = 1;
15443 }
15444 else
15445 {
15446 maskcnt = 1;
15447
15448 masks[maskcnt - 1] = mystrdup (mask);
15449 }
15450 }
15451
15452 // base
15453
15454 int wls_left = myargc - (optind + 2);
15455
15456 for (int i = 0; i < wls_left; i++)
15457 {
15458 char *filename = myargv[optind + 2 + i];
15459
15460 struct stat file_stat;
15461
15462 if (stat (filename, &file_stat) == -1)
15463 {
15464 log_error ("ERROR: %s: %s", filename, strerror (errno));
15465
15466 return (-1);
15467 }
15468
15469 uint is_dir = S_ISDIR (file_stat.st_mode);
15470
15471 if (is_dir == 0)
15472 {
15473 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15474
15475 dictcnt++;
15476
15477 dictfiles[dictcnt - 1] = filename;
15478 }
15479 else
15480 {
15481 // do not allow --keyspace w/ a directory
15482
15483 if (keyspace == 1)
15484 {
15485 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15486
15487 return (-1);
15488 }
15489
15490 char **dictionary_files = NULL;
15491
15492 dictionary_files = scan_directory (filename);
15493
15494 if (dictionary_files != NULL)
15495 {
15496 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15497
15498 for (int d = 0; dictionary_files[d] != NULL; d++)
15499 {
15500 char *l1_filename = dictionary_files[d];
15501
15502 struct stat l1_stat;
15503
15504 if (stat (l1_filename, &l1_stat) == -1)
15505 {
15506 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15507
15508 return (-1);
15509 }
15510
15511 if (S_ISREG (l1_stat.st_mode))
15512 {
15513 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15514
15515 dictcnt++;
15516
15517 dictfiles[dictcnt - 1] = strdup (l1_filename);
15518 }
15519 }
15520 }
15521
15522 local_free (dictionary_files);
15523 }
15524 }
15525
15526 if (dictcnt < 1)
15527 {
15528 log_error ("ERROR: No usable dictionary file found.");
15529
15530 return (-1);
15531 }
15532
15533 if (increment)
15534 {
15535 maskcnt = 0;
15536
15537 uint mask_min = increment_min; // we can't reject smaller masks here
15538 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15539
15540 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15541 {
15542 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15543
15544 if (cur_mask == NULL) break;
15545
15546 masks[maskcnt] = cur_mask;
15547
15548 maskcnt++;
15549
15550 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15551 }
15552 }
15553 }
15554
15555 data.pw_min = pw_min;
15556 data.pw_max = pw_max;
15557
15558 /**
15559 * weak hash check
15560 */
15561
15562 if (weak_hash_threshold >= salts_cnt)
15563 {
15564 hc_device_param_t *device_param = NULL;
15565
15566 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15567 {
15568 device_param = &data.devices_param[device_id];
15569
15570 if (device_param->skipped) continue;
15571
15572 break;
15573 }
15574
15575 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15576
15577 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15578 {
15579 weak_hash_check (device_param, salt_pos);
15580 }
15581 }
15582
15583 // Display hack, guarantee that there is at least one \r before real start
15584
15585 if (data.quiet == 0) log_info_nn ("");
15586
15587 /**
15588 * status and monitor threads
15589 */
15590
15591 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15592
15593 hc_thread_t i_thread = 0;
15594
15595 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15596 {
15597 hc_thread_create (i_thread, thread_keypress, &benchmark);
15598 }
15599
15600 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15601
15602 uint ni_threads_cnt = 0;
15603
15604 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15605
15606 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15607
15608 ni_threads_cnt++;
15609
15610 /**
15611 * Outfile remove
15612 */
15613
15614 if (keyspace == 0)
15615 {
15616 if (outfile_check_timer != 0)
15617 {
15618 if (data.outfile_check_directory != NULL)
15619 {
15620 if ((hash_mode != 5200) &&
15621 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15622 (hash_mode != 9000))
15623 {
15624 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15625
15626 ni_threads_cnt++;
15627 }
15628 else
15629 {
15630 outfile_check_timer = 0;
15631 }
15632 }
15633 else
15634 {
15635 outfile_check_timer = 0;
15636 }
15637 }
15638 }
15639
15640 /**
15641 * Inform the user if we got some hashes remove because of the pot file remove feature
15642 */
15643
15644 if (data.quiet == 0)
15645 {
15646 if (potfile_remove_cracks > 0)
15647 {
15648 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15649 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15650 }
15651 }
15652
15653 data.outfile_check_timer = outfile_check_timer;
15654
15655 /**
15656 * main loop
15657 */
15658
15659 char **induction_dictionaries = NULL;
15660
15661 int induction_dictionaries_cnt = 0;
15662
15663 hcstat_table_t *root_table_buf = NULL;
15664 hcstat_table_t *markov_table_buf = NULL;
15665
15666 uint initial_restore_done = 0;
15667
15668 data.maskcnt = maskcnt;
15669
15670 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15671 {
15672 if (data.devices_status == STATUS_CRACKED) break;
15673
15674 data.devices_status = STATUS_INIT;
15675
15676 if (maskpos > rd->maskpos)
15677 {
15678 rd->dictpos = 0;
15679 }
15680
15681 rd->maskpos = maskpos;
15682 data.maskpos = maskpos;
15683
15684 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15685 {
15686 char *mask = masks[maskpos];
15687
15688 if (mask_from_file == 1)
15689 {
15690 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15691
15692 char *str_ptr;
15693 uint str_pos;
15694
15695 uint mask_offset = 0;
15696
15697 uint separator_cnt;
15698
15699 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15700 {
15701 str_ptr = strstr (mask + mask_offset, ",");
15702
15703 if (str_ptr == NULL) break;
15704
15705 str_pos = str_ptr - mask;
15706
15707 // escaped separator, i.e. "\,"
15708
15709 if (str_pos > 0)
15710 {
15711 if (mask[str_pos - 1] == '\\')
15712 {
15713 separator_cnt --;
15714
15715 mask_offset = str_pos + 1;
15716
15717 continue;
15718 }
15719 }
15720
15721 // reset the offset
15722
15723 mask_offset = 0;
15724
15725 mask[str_pos] = '\0';
15726
15727 switch (separator_cnt)
15728 {
15729 case 0:
15730 mp_reset_usr (mp_usr, 0);
15731
15732 custom_charset_1 = mask;
15733 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15734 break;
15735
15736 case 1:
15737 mp_reset_usr (mp_usr, 1);
15738
15739 custom_charset_2 = mask;
15740 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15741 break;
15742
15743 case 2:
15744 mp_reset_usr (mp_usr, 2);
15745
15746 custom_charset_3 = mask;
15747 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15748 break;
15749
15750 case 3:
15751 mp_reset_usr (mp_usr, 3);
15752
15753 custom_charset_4 = mask;
15754 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15755 break;
15756 }
15757
15758 mask = mask + str_pos + 1;
15759 }
15760 }
15761
15762 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15763 {
15764 if (maskpos > 0)
15765 {
15766 local_free (css_buf);
15767 local_free (data.root_css_buf);
15768 local_free (data.markov_css_buf);
15769
15770 local_free (masks[maskpos - 1]);
15771 }
15772
15773 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15774
15775 data.mask = mask;
15776 data.css_cnt = css_cnt;
15777 data.css_buf = css_buf;
15778
15779 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15780
15781 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15782
15783 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15784 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15785
15786 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15787
15788 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15789
15790 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15791 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15792
15793 data.root_css_buf = root_css_buf;
15794 data.markov_css_buf = markov_css_buf;
15795
15796 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15797
15798 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15799
15800 local_free (root_table_buf);
15801 local_free (markov_table_buf);
15802
15803 // args
15804
15805 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15806 {
15807 hc_device_param_t *device_param = &data.devices_param[device_id];
15808
15809 if (device_param->skipped) continue;
15810
15811 device_param->kernel_params_mp[0] = &device_param->d_combs;
15812 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15813 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15814
15815 device_param->kernel_params_mp_buf64[3] = 0;
15816 device_param->kernel_params_mp_buf32[4] = css_cnt;
15817 device_param->kernel_params_mp_buf32[5] = 0;
15818 device_param->kernel_params_mp_buf32[6] = 0;
15819 device_param->kernel_params_mp_buf32[7] = 0;
15820
15821 if (attack_mode == ATTACK_MODE_HYBRID1)
15822 {
15823 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15824 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15825 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15826 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15827 }
15828 else if (attack_mode == ATTACK_MODE_HYBRID2)
15829 {
15830 device_param->kernel_params_mp_buf32[5] = 0;
15831 device_param->kernel_params_mp_buf32[6] = 0;
15832 device_param->kernel_params_mp_buf32[7] = 0;
15833 }
15834
15835 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]);
15836 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]);
15837 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]);
15838
15839 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);
15840 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);
15841 }
15842 }
15843 else if (attack_mode == ATTACK_MODE_BF)
15844 {
15845 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15846
15847 if (increment)
15848 {
15849 for (uint i = 0; i < dictcnt; i++)
15850 {
15851 local_free (dictfiles[i]);
15852 }
15853
15854 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15855 {
15856 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15857
15858 if (l1_filename == NULL) break;
15859
15860 dictcnt++;
15861
15862 dictfiles[dictcnt - 1] = l1_filename;
15863 }
15864 }
15865 else
15866 {
15867 dictcnt++;
15868
15869 dictfiles[dictcnt - 1] = mask;
15870 }
15871
15872 if (dictcnt == 0)
15873 {
15874 log_error ("ERROR: Mask is too small");
15875
15876 return (-1);
15877 }
15878 }
15879 }
15880
15881 free (induction_dictionaries);
15882
15883 // induction_dictionaries_cnt = 0; // implied
15884
15885 if (attack_mode != ATTACK_MODE_BF)
15886 {
15887 if (keyspace == 0)
15888 {
15889 induction_dictionaries = scan_directory (induction_directory);
15890
15891 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15892 }
15893 }
15894
15895 if (induction_dictionaries_cnt)
15896 {
15897 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15898 }
15899
15900 /**
15901 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15902 */
15903 if (keyspace == 1)
15904 {
15905 if ((maskcnt > 1) || (dictcnt > 1))
15906 {
15907 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15908
15909 return (-1);
15910 }
15911 }
15912
15913 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15914 {
15915 char *subid = logfile_generate_subid ();
15916
15917 data.subid = subid;
15918
15919 logfile_sub_msg ("START");
15920
15921 data.devices_status = STATUS_INIT;
15922
15923 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
15924 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
15925 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
15926
15927 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15928
15929 data.cpt_pos = 0;
15930
15931 data.cpt_start = time (NULL);
15932
15933 data.cpt_total = 0;
15934
15935 if (data.restore == 0)
15936 {
15937 rd->words_cur = skip;
15938
15939 skip = 0;
15940
15941 data.skip = 0;
15942 }
15943
15944 data.ms_paused = 0;
15945
15946 data.words_cur = rd->words_cur;
15947
15948 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15949 {
15950 hc_device_param_t *device_param = &data.devices_param[device_id];
15951
15952 if (device_param->skipped) continue;
15953
15954 device_param->speed_pos = 0;
15955
15956 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
15957 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
15958 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
15959
15960 device_param->exec_pos = 0;
15961
15962 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
15963
15964 device_param->kernel_power = device_param->kernel_power_user;
15965
15966 device_param->outerloop_pos = 0;
15967 device_param->outerloop_left = 0;
15968 device_param->innerloop_pos = 0;
15969 device_param->innerloop_left = 0;
15970
15971 // some more resets:
15972
15973 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
15974
15975 device_param->pws_cnt = 0;
15976
15977 device_param->words_off = 0;
15978 device_param->words_done = 0;
15979 }
15980
15981 data.kernel_power_div = 0;
15982
15983 // figure out some workload
15984
15985 if (attack_mode == ATTACK_MODE_STRAIGHT)
15986 {
15987 if (data.wordlist_mode == WL_MODE_FILE)
15988 {
15989 char *dictfile = NULL;
15990
15991 if (induction_dictionaries_cnt)
15992 {
15993 dictfile = induction_dictionaries[0];
15994 }
15995 else
15996 {
15997 dictfile = dictfiles[dictpos];
15998 }
15999
16000 data.dictfile = dictfile;
16001
16002 logfile_sub_string (dictfile);
16003
16004 for (uint i = 0; i < rp_files_cnt; i++)
16005 {
16006 logfile_sub_var_string ("rulefile", rp_files[i]);
16007 }
16008
16009 FILE *fd2 = fopen (dictfile, "rb");
16010
16011 if (fd2 == NULL)
16012 {
16013 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16014
16015 return (-1);
16016 }
16017
16018 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16019
16020 fclose (fd2);
16021
16022 if (data.words_cnt == 0)
16023 {
16024 if (data.devices_status == STATUS_CRACKED) break;
16025 if (data.devices_status == STATUS_ABORTED) break;
16026
16027 dictpos++;
16028
16029 continue;
16030 }
16031 }
16032 }
16033 else if (attack_mode == ATTACK_MODE_COMBI)
16034 {
16035 char *dictfile = data.dictfile;
16036 char *dictfile2 = data.dictfile2;
16037
16038 logfile_sub_string (dictfile);
16039 logfile_sub_string (dictfile2);
16040
16041 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
16042 {
16043 FILE *fd2 = fopen (dictfile, "rb");
16044
16045 if (fd2 == NULL)
16046 {
16047 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16048
16049 return (-1);
16050 }
16051
16052 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16053
16054 fclose (fd2);
16055 }
16056 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
16057 {
16058 FILE *fd2 = fopen (dictfile2, "rb");
16059
16060 if (fd2 == NULL)
16061 {
16062 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16063
16064 return (-1);
16065 }
16066
16067 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
16068
16069 fclose (fd2);
16070 }
16071
16072 if (data.words_cnt == 0)
16073 {
16074 if (data.devices_status == STATUS_CRACKED) break;
16075 if (data.devices_status == STATUS_ABORTED) break;
16076
16077 dictpos++;
16078
16079 continue;
16080 }
16081 }
16082 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16083 {
16084 char *dictfile = NULL;
16085
16086 if (induction_dictionaries_cnt)
16087 {
16088 dictfile = induction_dictionaries[0];
16089 }
16090 else
16091 {
16092 dictfile = dictfiles[dictpos];
16093 }
16094
16095 data.dictfile = dictfile;
16096
16097 char *mask = data.mask;
16098
16099 logfile_sub_string (dictfile);
16100 logfile_sub_string (mask);
16101
16102 FILE *fd2 = fopen (dictfile, "rb");
16103
16104 if (fd2 == NULL)
16105 {
16106 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16107
16108 return (-1);
16109 }
16110
16111 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16112
16113 fclose (fd2);
16114
16115 if (data.words_cnt == 0)
16116 {
16117 if (data.devices_status == STATUS_CRACKED) break;
16118 if (data.devices_status == STATUS_ABORTED) break;
16119
16120 dictpos++;
16121
16122 continue;
16123 }
16124 }
16125 else if (attack_mode == ATTACK_MODE_BF)
16126 {
16127 local_free (css_buf);
16128 local_free (data.root_css_buf);
16129 local_free (data.markov_css_buf);
16130
16131 char *mask = dictfiles[dictpos];
16132
16133 logfile_sub_string (mask);
16134
16135 // base
16136
16137 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16138
16139 if (opts_type & OPTS_TYPE_PT_UNICODE)
16140 {
16141 uint css_cnt_unicode = css_cnt * 2;
16142
16143 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
16144
16145 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
16146 {
16147 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
16148
16149 css_buf_unicode[j + 1].cs_buf[0] = 0;
16150 css_buf_unicode[j + 1].cs_len = 1;
16151 }
16152
16153 free (css_buf);
16154
16155 css_buf = css_buf_unicode;
16156 css_cnt = css_cnt_unicode;
16157 }
16158
16159 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
16160
16161 uint mask_min = pw_min;
16162 uint mask_max = pw_max;
16163
16164 if (opts_type & OPTS_TYPE_PT_UNICODE)
16165 {
16166 mask_min *= 2;
16167 mask_max *= 2;
16168 }
16169
16170 if ((css_cnt < mask_min) || (css_cnt > mask_max))
16171 {
16172 if (css_cnt < mask_min)
16173 {
16174 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
16175 }
16176
16177 if (css_cnt > mask_max)
16178 {
16179 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
16180 }
16181
16182 // skip to next mask
16183
16184 dictpos++;
16185
16186 rd->dictpos = dictpos;
16187
16188 logfile_sub_msg ("STOP");
16189
16190 continue;
16191 }
16192
16193 uint save_css_cnt = css_cnt;
16194
16195 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16196 {
16197 if (opti_type & OPTI_TYPE_APPENDED_SALT)
16198 {
16199 uint salt_len = (uint) data.salts_buf[0].salt_len;
16200 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
16201
16202 uint css_cnt_salt = css_cnt + salt_len;
16203
16204 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
16205
16206 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
16207
16208 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
16209 {
16210 css_buf_salt[j].cs_buf[0] = salt_buf[i];
16211 css_buf_salt[j].cs_len = 1;
16212 }
16213
16214 free (css_buf);
16215
16216 css_buf = css_buf_salt;
16217 css_cnt = css_cnt_salt;
16218 }
16219 }
16220
16221 data.mask = mask;
16222 data.css_cnt = css_cnt;
16223 data.css_buf = css_buf;
16224
16225 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
16226
16227 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16228
16229 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16230
16231 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16232 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16233
16234 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16235
16236 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16237
16238 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16239 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16240
16241 data.root_css_buf = root_css_buf;
16242 data.markov_css_buf = markov_css_buf;
16243
16244 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16245
16246 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16247
16248 local_free (root_table_buf);
16249 local_free (markov_table_buf);
16250
16251 // copy + args
16252
16253 uint css_cnt_l = css_cnt;
16254 uint css_cnt_r;
16255
16256 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16257 {
16258 if (save_css_cnt < 6)
16259 {
16260 css_cnt_r = 1;
16261 }
16262 else if (save_css_cnt == 6)
16263 {
16264 css_cnt_r = 2;
16265 }
16266 else
16267 {
16268 if (opts_type & OPTS_TYPE_PT_UNICODE)
16269 {
16270 if (save_css_cnt == 8 || save_css_cnt == 10)
16271 {
16272 css_cnt_r = 2;
16273 }
16274 else
16275 {
16276 css_cnt_r = 4;
16277 }
16278 }
16279 else
16280 {
16281 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
16282 {
16283 css_cnt_r = 3;
16284 }
16285 else
16286 {
16287 css_cnt_r = 4;
16288 }
16289 }
16290 }
16291 }
16292 else
16293 {
16294 css_cnt_r = 1;
16295
16296 /* unfinished code?
16297 int sum = css_buf[css_cnt_r - 1].cs_len;
16298
16299 for (uint i = 1; i < 4 && i < css_cnt; i++)
16300 {
16301 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
16302
16303 css_cnt_r++;
16304
16305 sum *= css_buf[css_cnt_r - 1].cs_len;
16306 }
16307 */
16308 }
16309
16310 css_cnt_l -= css_cnt_r;
16311
16312 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
16313
16314 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16315 {
16316 hc_device_param_t *device_param = &data.devices_param[device_id];
16317
16318 if (device_param->skipped) continue;
16319
16320 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
16321 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
16322 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
16323
16324 device_param->kernel_params_mp_l_buf64[3] = 0;
16325 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
16326 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
16327 device_param->kernel_params_mp_l_buf32[6] = 0;
16328 device_param->kernel_params_mp_l_buf32[7] = 0;
16329 device_param->kernel_params_mp_l_buf32[8] = 0;
16330
16331 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
16332 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
16333 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
16334 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
16335
16336 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
16337 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
16338 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
16339
16340 device_param->kernel_params_mp_r_buf64[3] = 0;
16341 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
16342 device_param->kernel_params_mp_r_buf32[5] = 0;
16343 device_param->kernel_params_mp_r_buf32[6] = 0;
16344 device_param->kernel_params_mp_r_buf32[7] = 0;
16345
16346 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]);
16347 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]);
16348 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]);
16349
16350 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]);
16351 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]);
16352 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]);
16353
16354 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);
16355 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);
16356 }
16357 }
16358
16359 u64 words_base = data.words_cnt;
16360
16361 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16362 {
16363 if (data.kernel_rules_cnt)
16364 {
16365 words_base /= data.kernel_rules_cnt;
16366 }
16367 }
16368 else if (data.attack_kern == ATTACK_KERN_COMBI)
16369 {
16370 if (data.combs_cnt)
16371 {
16372 words_base /= data.combs_cnt;
16373 }
16374 }
16375 else if (data.attack_kern == ATTACK_KERN_BF)
16376 {
16377 if (data.bfs_cnt)
16378 {
16379 words_base /= data.bfs_cnt;
16380 }
16381 }
16382
16383 data.words_base = words_base;
16384
16385 if (keyspace == 1)
16386 {
16387 log_info ("%llu", (unsigned long long int) words_base);
16388
16389 return (0);
16390 }
16391
16392 if (data.words_cur > data.words_base)
16393 {
16394 log_error ("ERROR: restore value greater keyspace");
16395
16396 return (-1);
16397 }
16398
16399 if (data.words_cur)
16400 {
16401 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16402 {
16403 for (uint i = 0; i < data.salts_cnt; i++)
16404 {
16405 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16406 }
16407 }
16408 else if (data.attack_kern == ATTACK_KERN_COMBI)
16409 {
16410 for (uint i = 0; i < data.salts_cnt; i++)
16411 {
16412 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16413 }
16414 }
16415 else if (data.attack_kern == ATTACK_KERN_BF)
16416 {
16417 for (uint i = 0; i < data.salts_cnt; i++)
16418 {
16419 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16420 }
16421 }
16422 }
16423
16424 /*
16425 * Inform user about possible slow speeds
16426 */
16427
16428 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16429 {
16430 if (data.words_base < kernel_power_all)
16431 {
16432 if (quiet == 0)
16433 {
16434 log_info ("");
16435 log_info ("ATTENTION!");
16436 log_info (" The wordlist or mask you are using is too small.");
16437 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
16438 log_info (" The cracking speed will drop.");
16439 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16440 log_info ("");
16441 }
16442 }
16443 }
16444
16445 /*
16446 * Update loopback file
16447 */
16448
16449 if (loopback == 1)
16450 {
16451 time_t now;
16452
16453 time (&now);
16454
16455 uint random_num = get_random_num (0, 9999);
16456
16457 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16458
16459 data.loopback_file = loopback_file;
16460 }
16461
16462 /*
16463 * Update dictionary statistic
16464 */
16465
16466 if (keyspace == 0)
16467 {
16468 dictstat_fp = fopen (dictstat, "wb");
16469
16470 if (dictstat_fp)
16471 {
16472 lock_file (dictstat_fp);
16473
16474 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16475
16476 fclose (dictstat_fp);
16477 }
16478 }
16479
16480 data.devices_status = STATUS_RUNNING;
16481
16482 if (initial_restore_done == 0)
16483 {
16484 if (data.restore_disable == 0) cycle_restore ();
16485
16486 initial_restore_done = 1;
16487 }
16488
16489 hc_timer_set (&data.timer_running);
16490
16491 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16492 {
16493 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16494 {
16495 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16496 if (quiet == 0) fflush (stdout);
16497 }
16498 }
16499 else if (wordlist_mode == WL_MODE_STDIN)
16500 {
16501 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16502 if (data.quiet == 0) log_info ("");
16503 }
16504
16505 time_t runtime_start;
16506
16507 time (&runtime_start);
16508
16509 data.runtime_start = runtime_start;
16510
16511 /**
16512 * create cracker threads
16513 */
16514
16515 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
16516
16517 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16518 {
16519 hc_device_param_t *device_param = &devices_param[device_id];
16520
16521 if (wordlist_mode == WL_MODE_STDIN)
16522 {
16523 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16524 }
16525 else
16526 {
16527 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16528 }
16529 }
16530
16531 // wait for crack threads to exit
16532
16533 hc_thread_wait (data.devices_cnt, c_threads);
16534
16535 local_free (c_threads);
16536
16537 data.restore = 0;
16538
16539 // finalize task
16540
16541 logfile_sub_var_uint ("status-after-work", data.devices_status);
16542
16543 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16544
16545 if (data.devices_status == STATUS_CRACKED) break;
16546 if (data.devices_status == STATUS_ABORTED) break;
16547
16548 if (data.devices_status == STATUS_BYPASS)
16549 {
16550 data.devices_status = STATUS_RUNNING;
16551 }
16552
16553 if (induction_dictionaries_cnt)
16554 {
16555 unlink (induction_dictionaries[0]);
16556 }
16557
16558 free (induction_dictionaries);
16559
16560 if (attack_mode != ATTACK_MODE_BF)
16561 {
16562 induction_dictionaries = scan_directory (induction_directory);
16563
16564 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16565 }
16566
16567 if (benchmark == 0)
16568 {
16569 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16570 {
16571 if (quiet == 0) clear_prompt ();
16572
16573 if (quiet == 0) log_info ("");
16574
16575 if (status == 1)
16576 {
16577 status_display ();
16578 }
16579 else
16580 {
16581 if (quiet == 0) status_display ();
16582 }
16583
16584 if (quiet == 0) log_info ("");
16585 }
16586 }
16587
16588 if (attack_mode == ATTACK_MODE_BF)
16589 {
16590 dictpos++;
16591
16592 rd->dictpos = dictpos;
16593 }
16594 else
16595 {
16596 if (induction_dictionaries_cnt)
16597 {
16598 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16599 }
16600 else
16601 {
16602 dictpos++;
16603
16604 rd->dictpos = dictpos;
16605 }
16606 }
16607
16608 time_t runtime_stop;
16609
16610 time (&runtime_stop);
16611
16612 data.runtime_stop = runtime_stop;
16613
16614 logfile_sub_uint (runtime_start);
16615 logfile_sub_uint (runtime_stop);
16616
16617 logfile_sub_msg ("STOP");
16618
16619 global_free (subid);
16620 }
16621
16622 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16623
16624 if (data.devices_status == STATUS_CRACKED) break;
16625 if (data.devices_status == STATUS_ABORTED) break;
16626 if (data.devices_status == STATUS_QUIT) break;
16627
16628 if (data.devices_status == STATUS_BYPASS)
16629 {
16630 data.devices_status = STATUS_RUNNING;
16631 }
16632 }
16633
16634 // 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
16635
16636 if (attack_mode == ATTACK_MODE_STRAIGHT)
16637 {
16638 if (data.wordlist_mode == WL_MODE_FILE)
16639 {
16640 if (data.dictfile == NULL)
16641 {
16642 if (dictfiles != NULL)
16643 {
16644 data.dictfile = dictfiles[0];
16645
16646 hc_timer_set (&data.timer_running);
16647 }
16648 }
16649 }
16650 }
16651 // NOTE: combi is okay because it is already set beforehand
16652 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16653 {
16654 if (data.dictfile == NULL)
16655 {
16656 if (dictfiles != NULL)
16657 {
16658 hc_timer_set (&data.timer_running);
16659
16660 data.dictfile = dictfiles[0];
16661 }
16662 }
16663 }
16664 else if (attack_mode == ATTACK_MODE_BF)
16665 {
16666 if (data.mask == NULL)
16667 {
16668 hc_timer_set (&data.timer_running);
16669
16670 data.mask = masks[0];
16671 }
16672 }
16673
16674 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16675 {
16676 data.devices_status = STATUS_EXHAUSTED;
16677 }
16678
16679 // if cracked / aborted remove last induction dictionary
16680
16681 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16682 {
16683 struct stat induct_stat;
16684
16685 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16686 {
16687 unlink (induction_dictionaries[file_pos]);
16688 }
16689 }
16690
16691 // wait for non-interactive threads
16692
16693 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16694 {
16695 hc_thread_wait (1, &ni_threads[thread_idx]);
16696 }
16697
16698 local_free (ni_threads);
16699
16700 // wait for interactive threads
16701
16702 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16703 {
16704 hc_thread_wait (1, &i_thread);
16705 }
16706
16707 // we dont need restore file anymore
16708 if (data.restore_disable == 0)
16709 {
16710 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16711 {
16712 unlink (eff_restore_file);
16713 unlink (new_restore_file);
16714 }
16715 else
16716 {
16717 cycle_restore ();
16718 }
16719 }
16720
16721 // finally save left hashes
16722
16723 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16724 {
16725 save_hash ();
16726 }
16727
16728 /**
16729 * Clean up
16730 */
16731
16732 if (benchmark == 1)
16733 {
16734 status_benchmark ();
16735
16736 log_info ("");
16737 }
16738 else
16739 {
16740 if (quiet == 0) clear_prompt ();
16741
16742 if (quiet == 0) log_info ("");
16743
16744 if (status == 1)
16745 {
16746 status_display ();
16747 }
16748 else
16749 {
16750 if (quiet == 0) status_display ();
16751 }
16752
16753 if (quiet == 0) log_info ("");
16754 }
16755
16756 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16757 {
16758 hc_device_param_t *device_param = &data.devices_param[device_id];
16759
16760 if (device_param->skipped) continue;
16761
16762 local_free (device_param->result);
16763
16764 local_free (device_param->combs_buf);
16765
16766 local_free (device_param->hooks_buf);
16767
16768 local_free (device_param->device_name);
16769
16770 local_free (device_param->device_name_chksum);
16771
16772 local_free (device_param->device_version);
16773
16774 local_free (device_param->driver_version);
16775
16776 if (device_param->pws_buf) myfree (device_param->pws_buf);
16777 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
16778 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
16779 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
16780 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
16781 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
16782 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
16783 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
16784 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
16785 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
16786 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
16787 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
16788 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
16789 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
16790 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
16791 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
16792 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
16793 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
16794 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
16795 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
16796 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
16797 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
16798 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
16799 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
16800 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
16801 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
16802 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
16803 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
16804 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
16805
16806 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
16807 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
16808 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
16809 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
16810 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
16811 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
16812 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
16813 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
16814 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
16815 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
16816
16817 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
16818 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
16819 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
16820
16821 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
16822 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
16823 }
16824
16825 // reset default fan speed
16826
16827 #ifdef HAVE_HWMON
16828 if (gpu_temp_disable == 0)
16829 {
16830 #ifdef HAVE_ADL
16831 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16832 {
16833 hc_thread_mutex_lock (mux_adl);
16834
16835 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16836 {
16837 hc_device_param_t *device_param = &data.devices_param[device_id];
16838
16839 if (device_param->skipped) continue;
16840
16841 if (data.hm_device[device_id].fan_supported == 1)
16842 {
16843 int fanspeed = temp_retain_fanspeed_value[device_id];
16844
16845 if (fanspeed == -1) continue;
16846
16847 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
16848
16849 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
16850 }
16851 }
16852
16853 hc_thread_mutex_unlock (mux_adl);
16854 }
16855 #endif // HAVE_ADL
16856 }
16857
16858 #ifdef HAVE_ADL
16859 // reset power tuning
16860
16861 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16862 {
16863 hc_thread_mutex_lock (mux_adl);
16864
16865 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16866 {
16867 hc_device_param_t *device_param = &data.devices_param[device_id];
16868
16869 if (device_param->skipped) continue;
16870
16871 if (data.hm_device[device_id].od_version == 6)
16872 {
16873 // check powertune capabilities first, if not available then skip device
16874
16875 int powertune_supported = 0;
16876
16877 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
16878 {
16879 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16880
16881 return (-1);
16882 }
16883
16884 if (powertune_supported != 0)
16885 {
16886 // powercontrol settings
16887
16888 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)
16889 {
16890 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16891
16892 return (-1);
16893 }
16894
16895 // clocks
16896
16897 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16898
16899 performance_state->iNumberOfPerformanceLevels = 2;
16900
16901 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
16902 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
16903 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
16904 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
16905
16906 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)
16907 {
16908 log_info ("ERROR: Failed to restore ADL performance state");
16909
16910 return (-1);
16911 }
16912
16913 local_free (performance_state);
16914 }
16915 }
16916 }
16917
16918 hc_thread_mutex_unlock (mux_adl);
16919 }
16920 #endif // HAVE_ADL
16921
16922 if (gpu_temp_disable == 0)
16923 {
16924 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
16925 if (data.hm_nv)
16926 {
16927 #if defined(LINUX) && defined(HAVE_NVML)
16928
16929 hm_NVML_nvmlShutdown (data.hm_nv);
16930
16931 nvml_close (data.hm_nv);
16932
16933 #elif defined(WIN) && (HAVE_NVAPI)
16934
16935 hm_NvAPI_Unload (data.hm_nv);
16936
16937 nvapi_close (data.hm_nv);
16938
16939 #endif
16940
16941 data.hm_nv = NULL;
16942 }
16943 #endif
16944
16945 #ifdef HAVE_ADL
16946 if (data.hm_amd)
16947 {
16948 hm_ADL_Main_Control_Destroy (data.hm_amd);
16949
16950 adl_close (data.hm_amd);
16951 data.hm_amd = NULL;
16952 }
16953 #endif
16954 }
16955 #endif // HAVE_HWMON
16956
16957 // free memory
16958
16959 local_free (masks);
16960
16961 local_free (dictstat_base);
16962
16963 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
16964 {
16965 pot_t *pot_ptr = &pot[pot_pos];
16966
16967 hash_t *hash = &pot_ptr->hash;
16968
16969 local_free (hash->digest);
16970
16971 if (isSalted)
16972 {
16973 local_free (hash->salt);
16974 }
16975 }
16976
16977 local_free (pot);
16978
16979 local_free (all_kernel_rules_cnt);
16980 local_free (all_kernel_rules_buf);
16981
16982 local_free (wl_data->buf);
16983 local_free (wl_data);
16984
16985 local_free (bitmap_s1_a);
16986 local_free (bitmap_s1_b);
16987 local_free (bitmap_s1_c);
16988 local_free (bitmap_s1_d);
16989 local_free (bitmap_s2_a);
16990 local_free (bitmap_s2_b);
16991 local_free (bitmap_s2_c);
16992 local_free (bitmap_s2_d);
16993
16994 #ifdef HAVE_HWMON
16995 local_free (temp_retain_fanspeed_value);
16996 #ifdef HAVE_ADL
16997 local_free (od_clock_mem_status);
16998 local_free (od_power_control_status);
16999 #endif // ADL
17000 #endif
17001
17002 global_free (devices_param);
17003
17004 global_free (kernel_rules_buf);
17005
17006 global_free (root_css_buf);
17007 global_free (markov_css_buf);
17008
17009 global_free (digests_buf);
17010 global_free (digests_shown);
17011 global_free (digests_shown_tmp);
17012
17013 global_free (salts_buf);
17014 global_free (salts_shown);
17015
17016 global_free (esalts_buf);
17017
17018 global_free (words_progress_done);
17019 global_free (words_progress_rejected);
17020 global_free (words_progress_restored);
17021
17022 if (pot_fp) fclose (pot_fp);
17023
17024 if (data.devices_status == STATUS_QUIT) break;
17025 }
17026
17027 // destroy others mutex
17028
17029 hc_thread_mutex_delete (mux_dispatcher);
17030 hc_thread_mutex_delete (mux_counter);
17031 hc_thread_mutex_delete (mux_display);
17032 hc_thread_mutex_delete (mux_adl);
17033
17034 // free memory
17035
17036 local_free (eff_restore_file);
17037 local_free (new_restore_file);
17038
17039 local_free (rd);
17040
17041 // tuning db
17042
17043 tuning_db_destroy (tuning_db);
17044
17045 // loopback
17046
17047 local_free (loopback_file);
17048
17049 if (loopback == 1) unlink (loopback_file);
17050
17051 // induction directory
17052
17053 if (induction_dir == NULL)
17054 {
17055 if (attack_mode != ATTACK_MODE_BF)
17056 {
17057 if (rmdir (induction_directory) == -1)
17058 {
17059 if (errno == ENOENT)
17060 {
17061 // good, we can ignore
17062 }
17063 else if (errno == ENOTEMPTY)
17064 {
17065 // good, we can ignore
17066 }
17067 else
17068 {
17069 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
17070
17071 return (-1);
17072 }
17073 }
17074
17075 local_free (induction_directory);
17076 }
17077 }
17078
17079 // outfile-check directory
17080
17081 if (outfile_check_dir == NULL)
17082 {
17083 if (rmdir (outfile_check_directory) == -1)
17084 {
17085 if (errno == ENOENT)
17086 {
17087 // good, we can ignore
17088 }
17089 else if (errno == ENOTEMPTY)
17090 {
17091 // good, we can ignore
17092 }
17093 else
17094 {
17095 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
17096
17097 return (-1);
17098 }
17099 }
17100
17101 local_free (outfile_check_directory);
17102 }
17103
17104 time_t proc_stop;
17105
17106 time (&proc_stop);
17107
17108 logfile_top_uint (proc_start);
17109 logfile_top_uint (proc_stop);
17110
17111 logfile_top_msg ("STOP");
17112
17113 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
17114 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
17115
17116 if (data.ocl) ocl_close (data.ocl);
17117
17118 if (data.devices_status == STATUS_ABORTED) return 2;
17119 if (data.devices_status == STATUS_QUIT) return 2;
17120 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
17121 if (data.devices_status == STATUS_EXHAUSTED) return 1;
17122 if (data.devices_status == STATUS_CRACKED) return 0;
17123
17124 return -1;
17125 }
Hashcat additions to support pwdhash