projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Do not modify the original positions of mac1, mac2, nonce1 and nonce2 in hccap files
[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 135
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 13400,
303 125
304 };
305
306 /**
307 * types
308 */
309
310 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
311
312 /**
313 * globals
314 */
315
316 static unsigned int full01 = 0x01010101;
317 static unsigned int full80 = 0x80808080;
318
319 int SUPPRESS_OUTPUT = 0;
320
321 hc_thread_mutex_t mux_adl;
322 hc_thread_mutex_t mux_counter;
323 hc_thread_mutex_t mux_dispatcher;
324 hc_thread_mutex_t mux_display;
325
326 hc_global_data_t data;
327
328 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
329
330 const char *USAGE_MINI[] =
331 {
332 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
333 "",
334 "Try --help for more help.",
335 NULL
336 };
337
338 const char *USAGE_BIG[] =
339 {
340 "%s, advanced password recovery",
341 "",
342 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
343 "",
344 "=======",
345 "Options",
346 "=======",
347 "",
348 "* General:",
349 "",
350 " -m, --hash-type=NUM Hash-type, see references below",
351 " -a, --attack-mode=NUM Attack-mode, see references below",
352 " -V, --version Print version",
353 " -h, --help Print help",
354 " --quiet Suppress output",
355 "",
356 "* Misc:",
357 "",
358 " --hex-charset Assume charset is given in hex",
359 " --hex-salt Assume salt is given in hex",
360 " --hex-wordlist Assume words in wordlist is given in hex",
361 " --force Ignore warnings",
362 " --status Enable automatic update of the status-screen",
363 " --status-timer=NUM Seconds between status-screen update",
364 " --status-automat Display the status view in a machine readable format",
365 " --loopback Add new plains to induct directory",
366 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
367 "",
368 "* Markov:",
369 "",
370 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
371 " --markov-disable Disables markov-chains, emulates classic brute-force",
372 " --markov-classic Enables classic markov-chains, no per-position enhancement",
373 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
374 "",
375 "* Session:",
376 "",
377 " --runtime=NUM Abort session after NUM seconds of runtime",
378 " --session=STR Define specific session name",
379 " --restore Restore session from --session",
380 " --restore-disable Do not write restore file",
381 "",
382 "* Files:",
383 "",
384 " -o, --outfile=FILE Define outfile for recovered hash",
385 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
386 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
387 " --outfile-check-timer=NUM Seconds between outfile checks",
388 " -p, --separator=CHAR Separator char for hashlists and outfile",
389 " --show Show cracked passwords only",
390 " --left Show un-cracked passwords only",
391 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
392 " --remove Enable remove of hash once it is cracked",
393 " --remove-timer=NUM Update input hash file each NUM seconds",
394 " --potfile-disable Do not write potfile",
395 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
396 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
397 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
398 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
399 " --logfile-disable Disable the logfile",
400 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
401 "",
402 "* Resources:",
403 "",
404 " -b, --benchmark Run benchmark",
405 " --benchmark-repeats=NUM Repeat the kernel on the device NUM times to increase benchmark accuracy",
406 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
407 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
408 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
409 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
410 " --opencl-platforms=STR OpenCL platforms to use, separate with comma",
411 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
412 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
413 " --opencl-vector-width=NUM OpenCL vector-width (either 1, 2, 4, 8 or 16), overrides value from device query",
414 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
415 " -n, --kernel-accel=NUM Workload tuning, increase the outer-loop step size",
416 " -u, --kernel-loops=NUM Workload tuning, increase the inner-loop step size",
417 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
418 #ifdef HAVE_HWMON
419 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
420 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
421 #ifdef HAVE_ADL
422 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
423 #endif
424 #endif
425 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
426 "",
427 "* Distributed:",
428 "",
429 " -s, --skip=NUM Skip number of words",
430 " -l, --limit=NUM Limit number of words",
431 " --keyspace Show keyspace base:mod values and quit",
432 "",
433 "* Rules:",
434 "",
435 " -j, --rule-left=RULE Single rule applied to each word from left dict",
436 " -k, --rule-right=RULE Single rule applied to each word from right dict",
437 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
438 " -g, --generate-rules=NUM Generate NUM random rules",
439 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
440 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
441 " --generate-rules-seed=NUM Force RNG seed to NUM",
442 "",
443 "* Custom charsets:",
444 "",
445 " -1, --custom-charset1=CS User-defined charsets",
446 " -2, --custom-charset2=CS Example:",
447 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
448 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
449 "",
450 "* Increment:",
451 "",
452 " -i, --increment Enable increment mode",
453 " --increment-min=NUM Start incrementing at NUM",
454 " --increment-max=NUM Stop incrementing at NUM",
455 "",
456 "==========",
457 "References",
458 "==========",
459 "",
460 "* Workload Profile:",
461 "",
462 " 1 = Interactive performance profile, kernel execution runtime to 8ms, lower latency desktop, lower speed",
463 " 2 = Default performance profile, kernel execution runtime to 16ms, economic setting",
464 " 3 = Headless performance profile, kernel execution runtime to 96ms, higher latency desktop, higher speed",
465 "",
466 "* OpenCL device-types:",
467 "",
468 " 1 = CPU devices",
469 " 2 = GPU devices",
470 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
471 "",
472 "* Outfile Formats:",
473 "",
474 " 1 = hash[:salt]",
475 " 2 = plain",
476 " 3 = hash[:salt]:plain",
477 " 4 = hex_plain",
478 " 5 = hash[:salt]:hex_plain",
479 " 6 = plain:hex_plain",
480 " 7 = hash[:salt]:plain:hex_plain",
481 " 8 = crackpos",
482 " 9 = hash[:salt]:crackpos",
483 " 10 = plain:crackpos",
484 " 11 = hash[:salt]:plain:crackpos",
485 " 12 = hex_plain:crackpos",
486 " 13 = hash[:salt]:hex_plain:crackpos",
487 " 14 = plain:hex_plain:crackpos",
488 " 15 = hash[:salt]:plain:hex_plain:crackpos",
489 "",
490 "* Debug mode output formats (for hybrid mode only, by using rules):",
491 "",
492 " 1 = save finding rule",
493 " 2 = save original word",
494 " 3 = save original word and finding rule",
495 " 4 = save original word, finding rule and modified plain",
496 "",
497 "* Built-in charsets:",
498 "",
499 " ?l = abcdefghijklmnopqrstuvwxyz",
500 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
501 " ?d = 0123456789",
502 " ?s = !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
503 " ?a = ?l?u?d?s",
504 " ?b = 0x00 - 0xff",
505 "",
506 "* Attack modes:",
507 "",
508 " 0 = Straight",
509 " 1 = Combination",
510 " 3 = Brute-force",
511 " 6 = Hybrid dict + mask",
512 " 7 = Hybrid mask + dict",
513 "",
514 "* Hash types:",
515 "",
516 "[[ Roll-your-own: Raw Hashes ]]",
517 "",
518 " 900 = MD4",
519 " 0 = MD5",
520 " 5100 = Half MD5",
521 " 100 = SHA1",
522 " 10800 = SHA-384",
523 " 1400 = SHA-256",
524 " 1700 = SHA-512",
525 " 5000 = SHA-3(Keccak)",
526 " 10100 = SipHash",
527 " 6000 = RipeMD160",
528 " 6100 = Whirlpool",
529 " 6900 = GOST R 34.11-94",
530 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
531 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
532 "",
533 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
534 "",
535 " 10 = md5($pass.$salt)",
536 " 20 = md5($salt.$pass)",
537 " 30 = md5(unicode($pass).$salt)",
538 " 40 = md5($salt.unicode($pass))",
539 " 3800 = md5($salt.$pass.$salt)",
540 " 3710 = md5($salt.md5($pass))",
541 " 2600 = md5(md5($pass)",
542 " 4300 = md5(strtoupper(md5($pass)))",
543 " 4400 = md5(sha1($pass))",
544 " 110 = sha1($pass.$salt)",
545 " 120 = sha1($salt.$pass)",
546 " 130 = sha1(unicode($pass).$salt)",
547 " 140 = sha1($salt.unicode($pass))",
548 " 4500 = sha1(sha1($pass)",
549 " 4700 = sha1(md5($pass))",
550 " 4900 = sha1($salt.$pass.$salt)",
551 " 1410 = sha256($pass.$salt)",
552 " 1420 = sha256($salt.$pass)",
553 " 1430 = sha256(unicode($pass).$salt)",
554 " 1440 = sha256($salt.unicode($pass))",
555 " 1710 = sha512($pass.$salt)",
556 " 1720 = sha512($salt.$pass)",
557 " 1730 = sha512(unicode($pass).$salt)",
558 " 1740 = sha512($salt.unicode($pass))",
559 "",
560 "[[ Roll-your-own: Authenticated Hashes ]]",
561 "",
562 " 50 = HMAC-MD5 (key = $pass)",
563 " 60 = HMAC-MD5 (key = $salt)",
564 " 150 = HMAC-SHA1 (key = $pass)",
565 " 160 = HMAC-SHA1 (key = $salt)",
566 " 1450 = HMAC-SHA256 (key = $pass)",
567 " 1460 = HMAC-SHA256 (key = $salt)",
568 " 1750 = HMAC-SHA512 (key = $pass)",
569 " 1760 = HMAC-SHA512 (key = $salt)",
570 "",
571 "[[ Generic KDF ]]",
572 "",
573 " 400 = phpass",
574 " 8900 = scrypt",
575 " 11900 = PBKDF2-HMAC-MD5",
576 " 12000 = PBKDF2-HMAC-SHA1",
577 " 10900 = PBKDF2-HMAC-SHA256",
578 " 12100 = PBKDF2-HMAC-SHA512",
579 "",
580 "[[ Network protocols, Challenge-Response ]]",
581 "",
582 " 23 = Skype",
583 " 2500 = WPA/WPA2",
584 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
585 " 5300 = IKE-PSK MD5",
586 " 5400 = IKE-PSK SHA1",
587 " 5500 = NetNTLMv1",
588 " 5500 = NetNTLMv1 + ESS",
589 " 5600 = NetNTLMv2",
590 " 7300 = IPMI2 RAKP HMAC-SHA1",
591 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
592 " 8300 = DNSSEC (NSEC3)",
593 " 10200 = Cram MD5",
594 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
595 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
596 " 11400 = SIP digest authentication (MD5)",
597 " 13100 = Kerberos 5 TGS-REP etype 23",
598 "",
599 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
600 "",
601 " 121 = SMF (Simple Machines Forum)",
602 " 400 = phpBB3",
603 " 2611 = vBulletin < v3.8.5",
604 " 2711 = vBulletin > v3.8.5",
605 " 2811 = MyBB",
606 " 2811 = IPB (Invison Power Board)",
607 " 8400 = WBB3 (Woltlab Burning Board)",
608 " 11 = Joomla < 2.5.18",
609 " 400 = Joomla > 2.5.18",
610 " 400 = Wordpress",
611 " 2612 = PHPS",
612 " 7900 = Drupal7",
613 " 21 = osCommerce",
614 " 21 = xt:Commerce",
615 " 11000 = PrestaShop",
616 " 124 = Django (SHA-1)",
617 " 10000 = Django (PBKDF2-SHA256)",
618 " 3711 = Mediawiki B type",
619 " 7600 = Redmine",
620 "",
621 "[[ Database Server ]]",
622 "",
623 " 12 = PostgreSQL",
624 " 131 = MSSQL(2000)",
625 " 132 = MSSQL(2005)",
626 " 1731 = MSSQL(2012)",
627 " 1731 = MSSQL(2014)",
628 " 200 = MySQL323",
629 " 300 = MySQL4.1/MySQL5",
630 " 3100 = Oracle H: Type (Oracle 7+)",
631 " 112 = Oracle S: Type (Oracle 11+)",
632 " 12300 = Oracle T: Type (Oracle 12+)",
633 " 8000 = Sybase ASE",
634 "",
635 "[[ HTTP, SMTP, LDAP Server ]]",
636 "",
637 " 141 = EPiServer 6.x < v4",
638 " 1441 = EPiServer 6.x > v4",
639 " 1600 = Apache $apr1$",
640 " 12600 = ColdFusion 10+",
641 " 1421 = hMailServer",
642 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
643 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
644 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
645 "",
646 "[[ Checksums ]]",
647 "",
648 " 11500 = CRC32",
649 "",
650 "[[ Operating-Systems ]]",
651 "",
652 " 3000 = LM",
653 " 1000 = NTLM",
654 " 1100 = Domain Cached Credentials (DCC), MS Cache",
655 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
656 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
657 " 1500 = descrypt, DES(Unix), Traditional DES",
658 " 12400 = BSDiCrypt, Extended DES",
659 " 500 = md5crypt $1$, MD5(Unix)",
660 " 3200 = bcrypt $2*$, Blowfish(Unix)",
661 " 7400 = sha256crypt $5$, SHA256(Unix)",
662 " 1800 = sha512crypt $6$, SHA512(Unix)",
663 " 122 = OSX v10.4",
664 " 122 = OSX v10.5",
665 " 122 = OSX v10.6",
666 " 1722 = OSX v10.7",
667 " 7100 = OSX v10.8",
668 " 7100 = OSX v10.9",
669 " 7100 = OSX v10.10",
670 " 6300 = AIX {smd5}",
671 " 6700 = AIX {ssha1}",
672 " 6400 = AIX {ssha256}",
673 " 6500 = AIX {ssha512}",
674 " 2400 = Cisco-PIX",
675 " 2410 = Cisco-ASA",
676 " 500 = Cisco-IOS $1$",
677 " 5700 = Cisco-IOS $4$",
678 " 9200 = Cisco-IOS $8$",
679 " 9300 = Cisco-IOS $9$",
680 " 22 = Juniper Netscreen/SSG (ScreenOS)",
681 " 501 = Juniper IVE",
682 " 5800 = Android PIN",
683 " 8100 = Citrix Netscaler",
684 " 8500 = RACF",
685 " 7200 = GRUB 2",
686 " 9900 = Radmin2",
687 " 125 = ArubaOS",
688 "",
689 "[[ Enterprise Application Software (EAS) ]]",
690 "",
691 " 7700 = SAP CODVN B (BCODE)",
692 " 7800 = SAP CODVN F/G (PASSCODE)",
693 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
694 " 8600 = Lotus Notes/Domino 5",
695 " 8700 = Lotus Notes/Domino 6",
696 " 9100 = Lotus Notes/Domino 8",
697 " 133 = PeopleSoft",
698 "",
699 "[[ Archives ]]",
700 "",
701 " 11600 = 7-Zip",
702 " 12500 = RAR3-hp",
703 " 13000 = RAR5",
704 " 13200 = AxCrypt",
705 " 13300 = AxCrypt in memory SHA1",
706 "",
707 "[[ Full-Disk encryptions (FDE) ]]",
708 "",
709 " 62XY = TrueCrypt 5.0+",
710 " X = 1 = PBKDF2-HMAC-RipeMD160",
711 " X = 2 = PBKDF2-HMAC-SHA512",
712 " X = 3 = PBKDF2-HMAC-Whirlpool",
713 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
714 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
715 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
716 " Y = 3 = XTS 1536 bit (Ciphers: All)",
717 " 8800 = Android FDE < v4.3",
718 " 12900 = Android FDE (Samsung DEK)",
719 " 12200 = eCryptfs",
720 "",
721 "[[ Documents ]]",
722 "",
723 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
724 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
725 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
726 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
727 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
728 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
729 " 9400 = MS Office 2007",
730 " 9500 = MS Office 2010",
731 " 9600 = MS Office 2013",
732 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
733 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
734 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
735 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
736 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
737 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
738 "",
739 "[[ Password Managers ]]",
740 "",
741 " 9000 = Password Safe v2",
742 " 5200 = Password Safe v3",
743 " 6800 = Lastpass",
744 " 6600 = 1Password, agilekeychain",
745 " 8200 = 1Password, cloudkeychain",
746 " 11300 = Bitcoin/Litecoin wallet.dat",
747 " 12700 = Blockchain, My Wallet",
748 " 13400 = Keepass 1 (AES/Twofish) and Keepass 2 (AES)",
749 "",
750 NULL
751 };
752
753 /**
754 * oclHashcat specific functions
755 */
756
757 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
758 {
759 int exec_pos = (int) device_param->exec_pos - last_num_entries;
760
761 if (exec_pos < 0) exec_pos += EXEC_CACHE;
762
763 double exec_ms_sum = 0;
764
765 int exec_ms_cnt = 0;
766
767 for (int i = 0; i < last_num_entries; i++)
768 {
769 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
770
771 if (exec_ms)
772 {
773 exec_ms_sum += exec_ms;
774
775 exec_ms_cnt++;
776 }
777 }
778
779 if (exec_ms_cnt == 0) return 0;
780
781 return exec_ms_sum / exec_ms_cnt;
782 }
783
784 void status_display_automat ()
785 {
786 FILE *out = stdout;
787
788 fprintf (out, "STATUS\t%u\t", data.devices_status);
789
790 /**
791 * speed new
792 */
793
794 fprintf (out, "SPEED\t");
795
796 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
797 {
798 hc_device_param_t *device_param = &data.devices_param[device_id];
799
800 if (device_param->skipped) continue;
801
802 u64 speed_cnt = 0;
803 float speed_ms = 0;
804
805 for (int i = 0; i < SPEED_CACHE; i++)
806 {
807 float rec_ms;
808
809 hc_timer_get (device_param->speed_rec[i], rec_ms);
810
811 if (rec_ms > SPEED_MAXAGE) continue;
812
813 speed_cnt += device_param->speed_cnt[i];
814 speed_ms += device_param->speed_ms[i];
815 }
816
817 speed_cnt /= SPEED_CACHE;
818 speed_ms /= SPEED_CACHE;
819
820 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
821 }
822
823 /**
824 * exec time
825 */
826
827 fprintf (out, "EXEC_RUNTIME\t");
828
829 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
830 {
831 hc_device_param_t *device_param = &data.devices_param[device_id];
832
833 if (device_param->skipped) continue;
834
835 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
836
837 fprintf (out, "%f\t", exec_ms_avg);
838 }
839
840 /**
841 * words_cur
842 */
843
844 u64 words_cur = get_lowest_words_done ();
845
846 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
847
848 /**
849 * counter
850 */
851
852 u64 progress_total = data.words_cnt * data.salts_cnt;
853
854 u64 all_done = 0;
855 u64 all_rejected = 0;
856 u64 all_restored = 0;
857
858 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
859 {
860 all_done += data.words_progress_done[salt_pos];
861 all_rejected += data.words_progress_rejected[salt_pos];
862 all_restored += data.words_progress_restored[salt_pos];
863 }
864
865 u64 progress_cur = all_restored + all_done + all_rejected;
866 u64 progress_end = progress_total;
867
868 u64 progress_skip = 0;
869
870 if (data.skip)
871 {
872 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
873
874 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
875 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
876 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
877 }
878
879 if (data.limit)
880 {
881 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
882
883 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
884 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
885 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
886 }
887
888 u64 progress_cur_relative_skip = progress_cur - progress_skip;
889 u64 progress_end_relative_skip = progress_end - progress_skip;
890
891 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
892
893 /**
894 * cracks
895 */
896
897 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
898 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
899
900 /**
901 * temperature
902 */
903
904 #ifdef HAVE_HWMON
905 if (data.gpu_temp_disable == 0)
906 {
907 fprintf (out, "TEMP\t");
908
909 hc_thread_mutex_lock (mux_adl);
910
911 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
912 {
913 hc_device_param_t *device_param = &data.devices_param[device_id];
914
915 if (device_param->skipped) continue;
916
917 int temp = hm_get_temperature_with_device_id (device_id);
918
919 fprintf (out, "%d\t", temp);
920 }
921
922 hc_thread_mutex_unlock (mux_adl);
923 }
924 #endif // HAVE_HWMON
925
926 /**
927 * flush
928 */
929
930 #ifdef _WIN
931 fputc ('\r', out);
932 fputc ('\n', out);
933 #endif
934
935 #ifdef _POSIX
936 fputc ('\n', out);
937 #endif
938
939 fflush (out);
940 }
941
942 void status_display ()
943 {
944 if (data.devices_status == STATUS_INIT) return;
945 if (data.devices_status == STATUS_STARTING) return;
946 if (data.devices_status == STATUS_BYPASS) return;
947
948 if (data.status_automat == 1)
949 {
950 status_display_automat ();
951
952 return;
953 }
954
955 char tmp_buf[1000] = { 0 };
956
957 uint tmp_len = 0;
958
959 log_info ("Session.Name...: %s", data.session);
960
961 char *status_type = strstatus (data.devices_status);
962
963 uint hash_mode = data.hash_mode;
964
965 char *hash_type = strhashtype (hash_mode); // not a bug
966
967 log_info ("Status.........: %s", status_type);
968
969 /**
970 * show rules
971 */
972
973 if (data.rp_files_cnt)
974 {
975 uint i;
976
977 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
978 {
979 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
980 }
981
982 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
983
984 log_info ("Rules.Type.....: %s", tmp_buf);
985
986 tmp_len = 0;
987 }
988
989 if (data.rp_gen)
990 {
991 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
992
993 if (data.rp_gen_seed)
994 {
995 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
996 }
997 }
998
999 /**
1000 * show input
1001 */
1002
1003 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1004 {
1005 if (data.wordlist_mode == WL_MODE_FILE)
1006 {
1007 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
1008 }
1009 else if (data.wordlist_mode == WL_MODE_STDIN)
1010 {
1011 log_info ("Input.Mode.....: Pipe");
1012 }
1013 }
1014 else if (data.attack_mode == ATTACK_MODE_COMBI)
1015 {
1016 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1017 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1018 }
1019 else if (data.attack_mode == ATTACK_MODE_BF)
1020 {
1021 char *mask = data.mask;
1022
1023 if (mask != NULL)
1024 {
1025 uint mask_len = data.css_cnt;
1026
1027 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1028
1029 if (mask_len > 0)
1030 {
1031 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1032 {
1033 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1034 {
1035 mask_len -= data.salts_buf[0].salt_len;
1036 }
1037 }
1038
1039 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1040
1041 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1042 }
1043
1044 if (data.maskcnt > 1)
1045 {
1046 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1047
1048 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1049 }
1050
1051 log_info ("Input.Mode.....: %s", tmp_buf);
1052 }
1053
1054 tmp_len = 0;
1055 }
1056 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1057 {
1058 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1059 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1060 }
1061 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1062 {
1063 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1064 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1065 }
1066
1067 if (data.digests_cnt == 1)
1068 {
1069 if (data.hash_mode == 2500)
1070 {
1071 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1072
1073 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1074 (char *) data.salts_buf[0].salt_buf,
1075 wpa->orig_mac1[0],
1076 wpa->orig_mac1[1],
1077 wpa->orig_mac1[2],
1078 wpa->orig_mac1[3],
1079 wpa->orig_mac1[4],
1080 wpa->orig_mac1[5],
1081 wpa->orig_mac2[0],
1082 wpa->orig_mac2[1],
1083 wpa->orig_mac2[2],
1084 wpa->orig_mac2[3],
1085 wpa->orig_mac2[4],
1086 wpa->orig_mac2[5]);
1087 }
1088 else if (data.hash_mode == 5200)
1089 {
1090 log_info ("Hash.Target....: File (%s)", data.hashfile);
1091 }
1092 else if (data.hash_mode == 9000)
1093 {
1094 log_info ("Hash.Target....: File (%s)", data.hashfile);
1095 }
1096 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1097 {
1098 log_info ("Hash.Target....: File (%s)", data.hashfile);
1099 }
1100 else
1101 {
1102 char out_buf[HCBUFSIZ] = { 0 };
1103
1104 ascii_digest (out_buf, 0, 0);
1105
1106 // limit length
1107 if (strlen (out_buf) > 40)
1108 {
1109 out_buf[41] = '.';
1110 out_buf[42] = '.';
1111 out_buf[43] = '.';
1112 out_buf[44] = 0;
1113 }
1114
1115 log_info ("Hash.Target....: %s", out_buf);
1116 }
1117 }
1118 else
1119 {
1120 if (data.hash_mode == 3000)
1121 {
1122 char out_buf1[32] = { 0 };
1123 char out_buf2[32] = { 0 };
1124
1125 ascii_digest (out_buf1, 0, 0);
1126 ascii_digest (out_buf2, 0, 1);
1127
1128 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1129 }
1130 else
1131 {
1132 log_info ("Hash.Target....: File (%s)", data.hashfile);
1133 }
1134 }
1135
1136 log_info ("Hash.Type......: %s", hash_type);
1137
1138 /**
1139 * speed new
1140 */
1141
1142 u64 speed_cnt[DEVICES_MAX] = { 0 };
1143 float speed_ms[DEVICES_MAX] = { 0 };
1144
1145 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1146 {
1147 hc_device_param_t *device_param = &data.devices_param[device_id];
1148
1149 if (device_param->skipped) continue;
1150
1151 // we need to clear values (set to 0) because in case the device does
1152 // not get new candidates it idles around but speed display would
1153 // show it as working.
1154 // if we instantly set it to 0 after reading it happens that the
1155 // speed can be shown as zero if the users refreshes too fast.
1156 // therefore, we add a timestamp when a stat was recorded and if its
1157 // too old we will not use it
1158
1159 speed_cnt[device_id] = 0;
1160 speed_ms[device_id] = 0;
1161
1162 for (int i = 0; i < SPEED_CACHE; i++)
1163 {
1164 float rec_ms;
1165
1166 hc_timer_get (device_param->speed_rec[i], rec_ms);
1167
1168 if (rec_ms > SPEED_MAXAGE) continue;
1169
1170 speed_cnt[device_id] += device_param->speed_cnt[i];
1171 speed_ms[device_id] += device_param->speed_ms[i];
1172 }
1173
1174 speed_cnt[device_id] /= SPEED_CACHE;
1175 speed_ms[device_id] /= SPEED_CACHE;
1176 }
1177
1178 float hashes_all_ms = 0;
1179
1180 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1181
1182 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1183 {
1184 hc_device_param_t *device_param = &data.devices_param[device_id];
1185
1186 if (device_param->skipped) continue;
1187
1188 hashes_dev_ms[device_id] = 0;
1189
1190 if (speed_ms[device_id])
1191 {
1192 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1193
1194 hashes_all_ms += hashes_dev_ms[device_id];
1195 }
1196 }
1197
1198 /**
1199 * exec time
1200 */
1201
1202 double exec_all_ms[DEVICES_MAX] = { 0 };
1203
1204 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1205 {
1206 hc_device_param_t *device_param = &data.devices_param[device_id];
1207
1208 if (device_param->skipped) continue;
1209
1210 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1211
1212 exec_all_ms[device_id] = exec_ms_avg;
1213 }
1214
1215 /**
1216 * timers
1217 */
1218
1219 float ms_running = 0;
1220
1221 hc_timer_get (data.timer_running, ms_running);
1222
1223 float ms_paused = data.ms_paused;
1224
1225 if (data.devices_status == STATUS_PAUSED)
1226 {
1227 float ms_paused_tmp = 0;
1228
1229 hc_timer_get (data.timer_paused, ms_paused_tmp);
1230
1231 ms_paused += ms_paused_tmp;
1232 }
1233
1234 #ifdef WIN
1235
1236 __time64_t sec_run = ms_running / 1000;
1237
1238 #else
1239
1240 time_t sec_run = ms_running / 1000;
1241
1242 #endif
1243
1244 if (sec_run)
1245 {
1246 char display_run[32] = { 0 };
1247
1248 struct tm tm_run;
1249
1250 struct tm *tmp = NULL;
1251
1252 #ifdef WIN
1253
1254 tmp = _gmtime64 (&sec_run);
1255
1256 #else
1257
1258 tmp = gmtime (&sec_run);
1259
1260 #endif
1261
1262 if (tmp != NULL)
1263 {
1264 memset (&tm_run, 0, sizeof (tm_run));
1265
1266 memcpy (&tm_run, tmp, sizeof (tm_run));
1267
1268 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1269
1270 char *start = ctime (&data.proc_start);
1271
1272 size_t start_len = strlen (start);
1273
1274 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1275 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1276
1277 log_info ("Time.Started...: %s (%s)", start, display_run);
1278 }
1279 }
1280 else
1281 {
1282 log_info ("Time.Started...: 0 secs");
1283 }
1284
1285 /**
1286 * counters
1287 */
1288
1289 u64 progress_total = data.words_cnt * data.salts_cnt;
1290
1291 u64 all_done = 0;
1292 u64 all_rejected = 0;
1293 u64 all_restored = 0;
1294
1295 u64 progress_noneed = 0;
1296
1297 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1298 {
1299 all_done += data.words_progress_done[salt_pos];
1300 all_rejected += data.words_progress_rejected[salt_pos];
1301 all_restored += data.words_progress_restored[salt_pos];
1302
1303 // Important for ETA only
1304
1305 if (data.salts_shown[salt_pos] == 1)
1306 {
1307 const u64 all = data.words_progress_done[salt_pos]
1308 + data.words_progress_rejected[salt_pos]
1309 + data.words_progress_restored[salt_pos];
1310
1311 const u64 left = data.words_cnt - all;
1312
1313 progress_noneed += left;
1314 }
1315 }
1316
1317 u64 progress_cur = all_restored + all_done + all_rejected;
1318 u64 progress_end = progress_total;
1319
1320 u64 progress_skip = 0;
1321
1322 if (data.skip)
1323 {
1324 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1325
1326 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1327 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1328 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1329 }
1330
1331 if (data.limit)
1332 {
1333 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1334
1335 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1336 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1337 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1338 }
1339
1340 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1341 u64 progress_end_relative_skip = progress_end - progress_skip;
1342
1343 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1344 {
1345 if (data.devices_status != STATUS_CRACKED)
1346 {
1347 #ifdef WIN
1348 __time64_t sec_etc = 0;
1349 #else
1350 time_t sec_etc = 0;
1351 #endif
1352
1353 if (hashes_all_ms)
1354 {
1355 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1356
1357 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1358
1359 sec_etc = ms_left / 1000;
1360 }
1361
1362 if (sec_etc == 0)
1363 {
1364 //log_info ("Time.Estimated.: 0 secs");
1365 }
1366 else if ((u64) sec_etc > ETC_MAX)
1367 {
1368 log_info ("Time.Estimated.: > 10 Years");
1369 }
1370 else
1371 {
1372 char display_etc[32] = { 0 };
1373
1374 struct tm tm_etc;
1375
1376 struct tm *tmp = NULL;
1377
1378 #ifdef WIN
1379
1380 tmp = _gmtime64 (&sec_etc);
1381
1382 #else
1383
1384 tmp = gmtime (&sec_etc);
1385
1386 #endif
1387
1388 if (tmp != NULL)
1389 {
1390 memset (&tm_etc, 0, sizeof (tm_etc));
1391
1392 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1393
1394 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1395
1396 time_t now;
1397
1398 time (&now);
1399
1400 now += sec_etc;
1401
1402 char *etc = ctime (&now);
1403
1404 size_t etc_len = strlen (etc);
1405
1406 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1407 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1408
1409 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1410 }
1411 }
1412 }
1413 }
1414
1415 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1416 {
1417 hc_device_param_t *device_param = &data.devices_param[device_id];
1418
1419 if (device_param->skipped) continue;
1420
1421 char display_dev_cur[16] = { 0 };
1422
1423 strncpy (display_dev_cur, "0.00", 4);
1424
1425 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1426
1427 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1428 }
1429
1430 char display_all_cur[16] = { 0 };
1431
1432 strncpy (display_all_cur, "0.00", 4);
1433
1434 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1435
1436 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1437
1438 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1439 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1440
1441 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);
1442
1443 // crack-per-time
1444
1445 if (data.digests_cnt > 100)
1446 {
1447 time_t now = time (NULL);
1448
1449 int cpt_cur_min = 0;
1450 int cpt_cur_hour = 0;
1451 int cpt_cur_day = 0;
1452
1453 for (int i = 0; i < CPT_BUF; i++)
1454 {
1455 const uint cracked = data.cpt_buf[i].cracked;
1456 const time_t timestamp = data.cpt_buf[i].timestamp;
1457
1458 if ((timestamp + 60) > now)
1459 {
1460 cpt_cur_min += cracked;
1461 }
1462
1463 if ((timestamp + 3600) > now)
1464 {
1465 cpt_cur_hour += cracked;
1466 }
1467
1468 if ((timestamp + 86400) > now)
1469 {
1470 cpt_cur_day += cracked;
1471 }
1472 }
1473
1474 float ms_real = ms_running - ms_paused;
1475
1476 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1477 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1478 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1479
1480 if ((data.cpt_start + 86400) < now)
1481 {
1482 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1483 cpt_cur_min,
1484 cpt_cur_hour,
1485 cpt_cur_day,
1486 cpt_avg_min,
1487 cpt_avg_hour,
1488 cpt_avg_day);
1489 }
1490 else if ((data.cpt_start + 3600) < now)
1491 {
1492 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1493 cpt_cur_min,
1494 cpt_cur_hour,
1495 cpt_avg_min,
1496 cpt_avg_hour,
1497 cpt_avg_day);
1498 }
1499 else if ((data.cpt_start + 60) < now)
1500 {
1501 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1502 cpt_cur_min,
1503 cpt_avg_min,
1504 cpt_avg_hour,
1505 cpt_avg_day);
1506 }
1507 else
1508 {
1509 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1510 cpt_avg_min,
1511 cpt_avg_hour,
1512 cpt_avg_day);
1513 }
1514 }
1515
1516 // Restore point
1517
1518 u64 restore_point = get_lowest_words_done ();
1519
1520 u64 restore_total = data.words_base;
1521
1522 float percent_restore = 0;
1523
1524 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1525
1526 if (progress_end_relative_skip)
1527 {
1528 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1529 {
1530 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1531 float percent_rejected = 0.0;
1532
1533 if (progress_cur)
1534 {
1535 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1536 }
1537
1538 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);
1539 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1540
1541 if (data.restore_disable == 0)
1542 {
1543 if (percent_finished != 1)
1544 {
1545 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1546 }
1547 }
1548 }
1549 }
1550 else
1551 {
1552 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1553 {
1554 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1555 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1556
1557 if (data.restore_disable == 0)
1558 {
1559 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1560 }
1561 }
1562 else
1563 {
1564 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1565 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1566
1567 // --restore not allowed if stdin is used -- really? why?
1568
1569 //if (data.restore_disable == 0)
1570 //{
1571 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1572 //}
1573 }
1574 }
1575
1576 #ifdef HAVE_HWMON
1577 if (data.gpu_temp_disable == 0)
1578 {
1579 hc_thread_mutex_lock (mux_adl);
1580
1581 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1582 {
1583 hc_device_param_t *device_param = &data.devices_param[device_id];
1584
1585 if (device_param->skipped) continue;
1586
1587 #define HM_STR_BUF_SIZE 255
1588
1589 if (data.hm_device[device_id].fan_supported == 1)
1590 {
1591 char utilization[HM_STR_BUF_SIZE] = { 0 };
1592 char temperature[HM_STR_BUF_SIZE] = { 0 };
1593 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1594
1595 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1596 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1597
1598 if (device_param->vendor_id == VENDOR_ID_AMD)
1599 {
1600 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1601 }
1602 else if (device_param->vendor_id == VENDOR_ID_NV)
1603 {
1604 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1605 }
1606
1607 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1608 }
1609 else
1610 {
1611 char utilization[HM_STR_BUF_SIZE] = { 0 };
1612 char temperature[HM_STR_BUF_SIZE] = { 0 };
1613
1614 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1615 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1616
1617 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1618 }
1619 }
1620
1621 hc_thread_mutex_unlock (mux_adl);
1622 }
1623 #endif // HAVE_HWMON
1624 }
1625
1626 static void status_benchmark ()
1627 {
1628 if (data.devices_status == STATUS_INIT) return;
1629 if (data.devices_status == STATUS_STARTING) return;
1630
1631 if (data.words_cnt == 0) return;
1632
1633 u64 speed_cnt[DEVICES_MAX] = { 0 };
1634 float speed_ms[DEVICES_MAX] = { 0 };
1635
1636 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1637 {
1638 hc_device_param_t *device_param = &data.devices_param[device_id];
1639
1640 if (device_param->skipped) continue;
1641
1642 speed_cnt[device_id] = 0;
1643 speed_ms[device_id] = 0;
1644
1645 for (int i = 0; i < SPEED_CACHE; i++)
1646 {
1647 speed_cnt[device_id] += device_param->speed_cnt[i];
1648 speed_ms[device_id] += device_param->speed_ms[i];
1649 }
1650
1651 speed_cnt[device_id] /= SPEED_CACHE;
1652 speed_ms[device_id] /= SPEED_CACHE;
1653 }
1654
1655 float hashes_all_ms = 0;
1656
1657 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1658
1659 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1660 {
1661 hc_device_param_t *device_param = &data.devices_param[device_id];
1662
1663 if (device_param->skipped) continue;
1664
1665 hashes_dev_ms[device_id] = 0;
1666
1667 if (speed_ms[device_id])
1668 {
1669 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1670
1671 hashes_all_ms += hashes_dev_ms[device_id];
1672 }
1673 }
1674
1675 /**
1676 * exec time
1677 */
1678
1679 double exec_all_ms[DEVICES_MAX] = { 0 };
1680
1681 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1682 {
1683 hc_device_param_t *device_param = &data.devices_param[device_id];
1684
1685 if (device_param->skipped) continue;
1686
1687 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1688
1689 exec_all_ms[device_id] = exec_ms_avg;
1690 }
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 char display_dev_cur[16] = { 0 };
1699
1700 strncpy (display_dev_cur, "0.00", 4);
1701
1702 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1703
1704 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1705 }
1706
1707 char display_all_cur[16] = { 0 };
1708
1709 strncpy (display_all_cur, "0.00", 4);
1710
1711 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1712
1713 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1714 }
1715
1716 /**
1717 * oclHashcat -only- functions
1718 */
1719
1720 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1721 {
1722 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1723 {
1724 if (attack_kern == ATTACK_KERN_STRAIGHT)
1725 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1726 else if (attack_kern == ATTACK_KERN_COMBI)
1727 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1728 else if (attack_kern == ATTACK_KERN_BF)
1729 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1730 }
1731 else
1732 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1733 }
1734
1735 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)
1736 {
1737 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1738 {
1739 if (attack_kern == ATTACK_KERN_STRAIGHT)
1740 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1741 else if (attack_kern == ATTACK_KERN_COMBI)
1742 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1743 else if (attack_kern == ATTACK_KERN_BF)
1744 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1745 }
1746 else
1747 {
1748 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1749 }
1750 }
1751
1752 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1753 {
1754 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1755 {
1756 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1757 }
1758 else
1759 {
1760 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1761 }
1762 }
1763
1764 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)
1765 {
1766 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1767 {
1768 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1769 }
1770 else
1771 {
1772 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1773 }
1774 }
1775
1776 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1777 {
1778 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1779 }
1780
1781 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1782 {
1783 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1784 }
1785
1786 static uint convert_from_hex (char *line_buf, const uint line_len)
1787 {
1788 if (line_len & 1) return (line_len); // not in hex
1789
1790 if (data.hex_wordlist == 1)
1791 {
1792 uint i;
1793 uint j;
1794
1795 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1796 {
1797 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1798 }
1799
1800 memset (line_buf + i, 0, line_len - i);
1801
1802 return (i);
1803 }
1804 else if (line_len >= 6) // $HEX[] = 6
1805 {
1806 if (line_buf[0] != '$') return (line_len);
1807 if (line_buf[1] != 'H') return (line_len);
1808 if (line_buf[2] != 'E') return (line_len);
1809 if (line_buf[3] != 'X') return (line_len);
1810 if (line_buf[4] != '[') return (line_len);
1811 if (line_buf[line_len - 1] != ']') return (line_len);
1812
1813 uint i;
1814 uint j;
1815
1816 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1817 {
1818 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1819 }
1820
1821 memset (line_buf + i, 0, line_len - i);
1822
1823 return (i);
1824 }
1825
1826 return (line_len);
1827 }
1828
1829 static void clear_prompt ()
1830 {
1831 fputc ('\r', stdout);
1832
1833 for (size_t i = 0; i < strlen (PROMPT); i++)
1834 {
1835 fputc (' ', stdout);
1836 }
1837
1838 fputc ('\r', stdout);
1839
1840 fflush (stdout);
1841 }
1842
1843 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1844 {
1845 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);
1846 }
1847
1848 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1849 {
1850 char *outfile = data.outfile;
1851 uint quiet = data.quiet;
1852 FILE *pot_fp = data.pot_fp;
1853 uint loopback = data.loopback;
1854 uint debug_mode = data.debug_mode;
1855 char *debug_file = data.debug_file;
1856
1857 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1858 int debug_rule_len = 0; // -1 error
1859 uint debug_plain_len = 0;
1860
1861 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1862
1863 // hash
1864
1865 char out_buf[HCBUFSIZ] = { 0 };
1866
1867 ascii_digest (out_buf, salt_pos, digest_pos);
1868
1869 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1870
1871 // plain
1872
1873 plain_t plain;
1874
1875 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);
1876
1877 uint gidvid = plain.gidvid;
1878 uint il_pos = plain.il_pos;
1879
1880 u64 crackpos = device_param->words_off;
1881
1882 uint plain_buf[16] = { 0 };
1883
1884 u8 *plain_ptr = (u8 *) plain_buf;
1885 unsigned int plain_len = 0;
1886
1887 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1888 {
1889 u64 gidd = gidvid;
1890 u64 gidm = 0;
1891
1892 pw_t pw;
1893
1894 gidd_to_pw_t (device_param, gidd, &pw);
1895
1896 for (int i = 0, j = gidm; i < 16; i++, j++)
1897 {
1898 plain_buf[i] = pw.i[j];
1899 }
1900
1901 plain_len = pw.pw_len;
1902
1903 const uint off = device_param->innerloop_pos + il_pos;
1904
1905 if (debug_mode > 0)
1906 {
1907 debug_rule_len = 0;
1908
1909 // save rule
1910 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1911 {
1912 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1913
1914 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1915 }
1916
1917 // save plain
1918 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1919 {
1920 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1921
1922 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1923
1924 debug_plain_len = plain_len;
1925 }
1926 }
1927
1928 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1929
1930 crackpos += gidvid;
1931 crackpos *= data.kernel_rules_cnt;
1932 crackpos += device_param->innerloop_pos + il_pos;
1933
1934 if (plain_len > data.pw_max) plain_len = data.pw_max;
1935 }
1936 else if (data.attack_mode == ATTACK_MODE_COMBI)
1937 {
1938 u64 gidd = gidvid;
1939 u64 gidm = 0;
1940
1941 pw_t pw;
1942
1943 gidd_to_pw_t (device_param, gidd, &pw);
1944
1945 for (int i = 0, j = gidm; i < 16; i++, j++)
1946 {
1947 plain_buf[i] = pw.i[j];
1948 }
1949
1950 plain_len = pw.pw_len;
1951
1952 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1953 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1954
1955 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1956 {
1957 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1958 }
1959 else
1960 {
1961 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1962
1963 memcpy (plain_ptr, comb_buf, comb_len);
1964 }
1965
1966 plain_len += comb_len;
1967
1968 crackpos += gidvid;
1969 crackpos *= data.combs_cnt;
1970 crackpos += device_param->innerloop_pos + il_pos;
1971
1972 if (data.pw_max != PW_DICTMAX1)
1973 {
1974 if (plain_len > data.pw_max) plain_len = data.pw_max;
1975 }
1976 }
1977 else if (data.attack_mode == ATTACK_MODE_BF)
1978 {
1979 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1980 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1981
1982 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1983 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1984
1985 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1986 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1987
1988 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1989 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1990
1991 plain_len = data.css_cnt;
1992
1993 crackpos += gidvid;
1994 crackpos *= data.bfs_cnt;
1995 crackpos += device_param->innerloop_pos + il_pos;
1996 }
1997 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1998 {
1999 u64 gidd = gidvid;
2000 u64 gidm = 0;
2001
2002 pw_t pw;
2003
2004 gidd_to_pw_t (device_param, gidd, &pw);
2005
2006 for (int i = 0, j = gidm; i < 16; i++, j++)
2007 {
2008 plain_buf[i] = pw.i[j];
2009 }
2010
2011 plain_len = pw.pw_len;
2012
2013 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2014
2015 uint start = 0;
2016 uint stop = device_param->kernel_params_mp_buf32[4];
2017
2018 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2019
2020 plain_len += start + stop;
2021
2022 crackpos += gidvid;
2023 crackpos *= data.combs_cnt;
2024 crackpos += device_param->innerloop_pos + il_pos;
2025
2026 if (data.pw_max != PW_DICTMAX1)
2027 {
2028 if (plain_len > data.pw_max) plain_len = data.pw_max;
2029 }
2030 }
2031 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2032 {
2033 u64 gidd = gidvid;
2034 u64 gidm = 0;
2035
2036 pw_t pw;
2037
2038 gidd_to_pw_t (device_param, gidd, &pw);
2039
2040 for (int i = 0, j = gidm; i < 16; i++, j++)
2041 {
2042 plain_buf[i] = pw.i[j];
2043 }
2044
2045 plain_len = pw.pw_len;
2046
2047 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2048
2049 uint start = 0;
2050 uint stop = device_param->kernel_params_mp_buf32[4];
2051
2052 memmove (plain_ptr + stop, plain_ptr, plain_len);
2053
2054 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2055
2056 plain_len += start + stop;
2057
2058 crackpos += gidvid;
2059 crackpos *= data.combs_cnt;
2060 crackpos += device_param->innerloop_pos + il_pos;
2061
2062 if (data.pw_max != PW_DICTMAX1)
2063 {
2064 if (plain_len > data.pw_max) plain_len = data.pw_max;
2065 }
2066 }
2067
2068 if (data.attack_mode == ATTACK_MODE_BF)
2069 {
2070 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2071 {
2072 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2073 {
2074 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2075 {
2076 plain_len = plain_len - data.salts_buf[0].salt_len;
2077 }
2078 }
2079
2080 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2081 {
2082 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2083 {
2084 plain_ptr[j] = plain_ptr[i];
2085 }
2086
2087 plain_len = plain_len / 2;
2088 }
2089 }
2090 }
2091
2092 // if enabled, update also the potfile
2093
2094 if (pot_fp)
2095 {
2096 lock_file (pot_fp);
2097
2098 fprintf (pot_fp, "%s:", out_buf);
2099
2100 format_plain (pot_fp, plain_ptr, plain_len, 1);
2101
2102 fputc ('\n', pot_fp);
2103
2104 fflush (pot_fp);
2105
2106 unlock_file (pot_fp);
2107 }
2108
2109 // outfile
2110
2111 FILE *out_fp = NULL;
2112
2113 if (outfile != NULL)
2114 {
2115 if ((out_fp = fopen (outfile, "ab")) == NULL)
2116 {
2117 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2118
2119 out_fp = stdout;
2120 }
2121 lock_file (out_fp);
2122 }
2123 else
2124 {
2125 out_fp = stdout;
2126
2127 if (quiet == 0) clear_prompt ();
2128 }
2129
2130 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2131
2132 if (outfile != NULL)
2133 {
2134 if (out_fp != stdout)
2135 {
2136 fclose (out_fp);
2137 }
2138 }
2139 else
2140 {
2141 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2142 {
2143 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2144 {
2145 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2146 if (quiet == 0) fflush (stdout);
2147 }
2148 }
2149 }
2150
2151 // loopback
2152
2153 if (loopback)
2154 {
2155 char *loopback_file = data.loopback_file;
2156
2157 FILE *fb_fp = NULL;
2158
2159 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2160 {
2161 lock_file (fb_fp);
2162
2163 format_plain (fb_fp, plain_ptr, plain_len, 1);
2164
2165 fputc ('\n', fb_fp);
2166
2167 fclose (fb_fp);
2168 }
2169 }
2170
2171 // (rule) debug mode
2172
2173 // the next check implies that:
2174 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2175 // - debug_mode > 0
2176
2177 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2178 {
2179 if (debug_rule_len < 0) debug_rule_len = 0;
2180
2181 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2182
2183 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2184
2185 if ((quiet == 0) && (debug_file == NULL))
2186 {
2187 fprintf (stdout, "%s", PROMPT);
2188 fflush (stdout);
2189 }
2190 }
2191 }
2192
2193 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2194 {
2195 salt_t *salt_buf = &data.salts_buf[salt_pos];
2196
2197 int found = 0;
2198
2199 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);
2200
2201 for (uint i = 0; i < KERNEL_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2202
2203 if (found == 1)
2204 {
2205 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2206
2207 log_info_nn ("");
2208
2209 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);
2210
2211 uint cpt_cracked = 0;
2212
2213 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2214 {
2215 uint idx = salt_buf->digests_offset + digest_pos;
2216
2217 if (data.digests_shown_tmp[idx] == 0) continue;
2218
2219 if (data.digests_shown[idx] == 1) continue;
2220
2221 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2222 {
2223 data.digests_shown[idx] = 1;
2224
2225 data.digests_done++;
2226
2227 cpt_cracked++;
2228
2229 salt_buf->digests_done++;
2230
2231 if (salt_buf->digests_done == salt_buf->digests_cnt)
2232 {
2233 data.salts_shown[salt_pos] = 1;
2234
2235 data.salts_done++;
2236 }
2237 }
2238
2239 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2240
2241 check_hash (device_param, salt_pos, digest_pos);
2242 }
2243
2244 if (cpt_cracked > 0)
2245 {
2246 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2247 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2248
2249 data.cpt_pos++;
2250
2251 data.cpt_total += cpt_cracked;
2252
2253 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2254 }
2255
2256 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2257 {
2258 // we need to reset cracked state on the device
2259 // otherwise host thinks again and again the hash was cracked
2260 // and returns invalid password each time
2261
2262 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2263
2264 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);
2265 }
2266
2267 memset (device_param->result, 0, device_param->size_results);
2268
2269 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);
2270 }
2271 }
2272
2273 static void save_hash ()
2274 {
2275 char *hashfile = data.hashfile;
2276
2277 char new_hashfile[256] = { 0 };
2278 char old_hashfile[256] = { 0 };
2279
2280 snprintf (new_hashfile, 255, "%s.new", hashfile);
2281 snprintf (old_hashfile, 255, "%s.old", hashfile);
2282
2283 unlink (new_hashfile);
2284
2285 char separator = data.separator;
2286
2287 FILE *fp = fopen (new_hashfile, "wb");
2288
2289 if (fp == NULL)
2290 {
2291 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2292
2293 exit (-1);
2294 }
2295
2296 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2297 {
2298 if (data.salts_shown[salt_pos] == 1) continue;
2299
2300 salt_t *salt_buf = &data.salts_buf[salt_pos];
2301
2302 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2303 {
2304 uint idx = salt_buf->digests_offset + digest_pos;
2305
2306 if (data.digests_shown[idx] == 1) continue;
2307
2308 if (data.hash_mode != 2500)
2309 {
2310 char out_buf[HCBUFSIZ] = { 0 };
2311
2312 if (data.username == 1)
2313 {
2314 user_t *user = data.hash_info[idx]->user;
2315
2316 uint i;
2317
2318 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2319
2320 fputc (separator, fp);
2321 }
2322
2323 ascii_digest (out_buf, salt_pos, digest_pos);
2324
2325 fputs (out_buf, fp);
2326
2327 log_out (fp, "");
2328 }
2329 else
2330 {
2331 hccap_t hccap;
2332
2333 to_hccap_t (&hccap, salt_pos, digest_pos);
2334
2335 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2336 }
2337 }
2338 }
2339
2340 fflush (fp);
2341
2342 fclose (fp);
2343
2344 unlink (old_hashfile);
2345
2346 if (rename (hashfile, old_hashfile) != 0)
2347 {
2348 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2349
2350 exit (-1);
2351 }
2352
2353 unlink (hashfile);
2354
2355 if (rename (new_hashfile, hashfile) != 0)
2356 {
2357 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2358
2359 exit (-1);
2360 }
2361
2362 unlink (old_hashfile);
2363 }
2364
2365 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2366 {
2367 // function called only in case kernel_power_all > words_left
2368
2369 float kernel_power_div = (float) (total_left) / kernel_power_all;
2370
2371 kernel_power_div += kernel_power_div / 100;
2372
2373 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2374
2375 while (kernel_power_new < total_left)
2376 {
2377 kernel_power_div += kernel_power_div / 100;
2378
2379 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2380 }
2381
2382 if (data.quiet == 0)
2383 {
2384 clear_prompt ();
2385
2386 log_info ("");
2387
2388 log_info ("INFO: approaching final keyspace, workload adjusted");
2389
2390 log_info ("");
2391
2392 fprintf (stdout, "%s", PROMPT);
2393
2394 fflush (stdout);
2395 }
2396
2397 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2398
2399 return kernel_power_div;
2400 }
2401
2402 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2403 {
2404 uint num_elements = num;
2405
2406 device_param->kernel_params_buf32[30] = data.combs_mode;
2407 device_param->kernel_params_buf32[31] = num;
2408
2409 uint kernel_threads = device_param->kernel_threads;
2410
2411 while (num_elements % kernel_threads) num_elements++;
2412
2413 cl_kernel kernel = NULL;
2414
2415 switch (kern_run)
2416 {
2417 case KERN_RUN_1: kernel = device_param->kernel1; break;
2418 case KERN_RUN_12: kernel = device_param->kernel12; break;
2419 case KERN_RUN_2: kernel = device_param->kernel2; break;
2420 case KERN_RUN_23: kernel = device_param->kernel23; break;
2421 case KERN_RUN_3: kernel = device_param->kernel3; break;
2422 }
2423
2424 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2425 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2426 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2427 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2428 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2429 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2430 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2431 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2432 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2433 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2434 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2435
2436 hc_timer_t timer;
2437
2438 hc_timer_set (&timer);
2439
2440 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2441 {
2442 const size_t global_work_size[3] = { num_elements, 32, 1 };
2443 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2444
2445 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2446 }
2447 else
2448 {
2449 size_t workgroup_size = 0;
2450
2451 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2452
2453 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2454
2455 const size_t global_work_size[3] = { num_elements, 1, 1 };
2456 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2457
2458 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2459 }
2460
2461 hc_clFlush (data.ocl, device_param->command_queue);
2462
2463 hc_clFinish (data.ocl, device_param->command_queue);
2464
2465 if (event_update)
2466 {
2467 float exec_time;
2468
2469 hc_timer_get (timer, exec_time);
2470
2471 uint exec_pos = device_param->exec_pos;
2472
2473 device_param->exec_ms[exec_pos] = exec_time;
2474
2475 exec_pos++;
2476
2477 if (exec_pos == EXEC_CACHE)
2478 {
2479 exec_pos = 0;
2480 }
2481
2482 device_param->exec_pos = exec_pos;
2483 }
2484 }
2485
2486 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2487 {
2488 uint num_elements = num;
2489
2490 switch (kern_run)
2491 {
2492 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2493 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2494 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2495 }
2496
2497 // causes problems with special threads like in bcrypt
2498 // const uint kernel_threads = device_param->kernel_threads;
2499
2500 uint kernel_threads = KERNEL_THREADS;
2501
2502 while (num_elements % kernel_threads) num_elements++;
2503
2504 cl_kernel kernel = NULL;
2505
2506 switch (kern_run)
2507 {
2508 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2509 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2510 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2511 }
2512
2513 switch (kern_run)
2514 {
2515 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2516 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2517 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2518 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2519 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2520 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2521 break;
2522 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2523 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2524 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2525 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2526 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2527 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2528 break;
2529 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2530 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2531 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2532 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2533 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2534 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2535 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2536 break;
2537 }
2538
2539 size_t workgroup_size = 0;
2540 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), &workgroup_size, NULL);
2541 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2542
2543 const size_t global_work_size[3] = { num_elements, 1, 1 };
2544 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2545
2546 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2547
2548 hc_clFlush (data.ocl, device_param->command_queue);
2549
2550 hc_clFinish (data.ocl, device_param->command_queue);
2551 }
2552
2553 static void run_kernel_tm (hc_device_param_t *device_param)
2554 {
2555 const uint num_elements = 1024; // fixed
2556
2557 uint kernel_threads = 32;
2558
2559 cl_kernel kernel = device_param->kernel_tm;
2560
2561 size_t workgroup_size = 0;
2562 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2563 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2564
2565 const size_t global_work_size[3] = { num_elements, 1, 1 };
2566 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2567
2568 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2569
2570 hc_clFlush (data.ocl, device_param->command_queue);
2571
2572 hc_clFinish (data.ocl, device_param->command_queue);
2573 }
2574
2575 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2576 {
2577 uint num_elements = num;
2578
2579 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2580 device_param->kernel_params_amp_buf32[6] = num_elements;
2581
2582 // causes problems with special threads like in bcrypt
2583 // const uint kernel_threads = device_param->kernel_threads;
2584
2585 uint kernel_threads = KERNEL_THREADS;
2586
2587 while (num_elements % kernel_threads) num_elements++;
2588
2589 cl_kernel kernel = device_param->kernel_amp;
2590
2591 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2592 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2593
2594 size_t workgroup_size = 0;
2595 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2596 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2597
2598 const size_t global_work_size[3] = { num_elements, 1, 1 };
2599 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2600
2601 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2602
2603 hc_clFlush (data.ocl, device_param->command_queue);
2604
2605 hc_clFinish (data.ocl, device_param->command_queue);
2606 }
2607
2608 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2609 {
2610 int rc = -1;
2611
2612 if (device_param->opencl_v12 && device_param->vendor_id == VENDOR_ID_AMD)
2613 {
2614 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2615
2616 const cl_uchar zero = 0;
2617
2618 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2619 }
2620
2621 if (rc != 0)
2622 {
2623 // NOTE: clEnqueueFillBuffer () always fails with -59
2624 // IOW, it's not supported by Nvidia ForceWare <= 352.21, also pocl segfaults, also on apple
2625 // How's that possible, OpenCL 1.2 support is advertised??
2626 // We need to workaround...
2627
2628 #define FILLSZ 0x100000
2629
2630 char *tmp = (char *) mymalloc (FILLSZ);
2631
2632 for (uint i = 0; i < size; i += FILLSZ)
2633 {
2634 const int left = size - i;
2635
2636 const int fillsz = MIN (FILLSZ, left);
2637
2638 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2639 }
2640
2641 myfree (tmp);
2642 }
2643 }
2644
2645 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)
2646 {
2647 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2648 {
2649 if (attack_mode == ATTACK_MODE_BF)
2650 {
2651 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2652 {
2653 const uint size_tm = 32 * sizeof (bs_word_t);
2654
2655 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2656
2657 run_kernel_tm (device_param);
2658
2659 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);
2660 }
2661 }
2662
2663 if (highest_pw_len < 16)
2664 {
2665 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2666 }
2667 else if (highest_pw_len < 32)
2668 {
2669 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2670 }
2671 else
2672 {
2673 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2674 }
2675 }
2676 else
2677 {
2678 run_kernel_amp (device_param, pws_cnt);
2679
2680 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2681
2682 if (opts_type & OPTS_TYPE_HOOK12)
2683 {
2684 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2685 }
2686
2687 uint iter = salt_buf->salt_iter;
2688
2689 uint loop_step = device_param->kernel_loops;
2690
2691 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2692 {
2693 uint loop_left = iter - loop_pos;
2694
2695 loop_left = MIN (loop_left, loop_step);
2696
2697 device_param->kernel_params_buf32[25] = loop_pos;
2698 device_param->kernel_params_buf32[26] = loop_left;
2699
2700 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2701
2702 if (data.devices_status == STATUS_CRACKED) break;
2703 if (data.devices_status == STATUS_ABORTED) break;
2704 if (data.devices_status == STATUS_QUIT) break;
2705 }
2706
2707 if (opts_type & OPTS_TYPE_HOOK23)
2708 {
2709 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2710
2711 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);
2712
2713 // do something with data
2714
2715 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);
2716 }
2717
2718 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2719 }
2720 }
2721
2722 static int run_rule_engine (const int rule_len, const char *rule_buf)
2723 {
2724 if (rule_len == 0)
2725 {
2726 return 0;
2727 }
2728 else if (rule_len == 1)
2729 {
2730 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2731 }
2732
2733 return 1;
2734 }
2735
2736 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2737 {
2738 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2739 {
2740 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);
2741 }
2742 else if (data.attack_kern == ATTACK_KERN_COMBI)
2743 {
2744 if (data.attack_mode == ATTACK_MODE_HYBRID2)
2745 {
2746 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2747 {
2748 for (u32 i = 0; i < pws_cnt; i++)
2749 {
2750 const u32 pw_len = device_param->pws_buf[i].pw_len;
2751
2752 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2753
2754 ptr[pw_len] = 0x01;
2755 }
2756 }
2757 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
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] = 0x80;
2766 }
2767 }
2768 }
2769
2770 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);
2771 }
2772 else if (data.attack_kern == ATTACK_KERN_BF)
2773 {
2774 const u64 off = device_param->words_off;
2775
2776 device_param->kernel_params_mp_l_buf64[3] = off;
2777
2778 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2779 }
2780 }
2781
2782 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops, const int repeat)
2783 {
2784 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2785
2786 device_param->kernel_params_buf32[26] = kernel_loops;
2787 device_param->kernel_params_buf32[27] = kernel_loops;
2788
2789 // init some fake words
2790
2791 for (u32 i = 0; i < kernel_power; i++)
2792 {
2793 device_param->pws_buf[i].i[0] = i;
2794 device_param->pws_buf[i].i[1] = 0x01234567;
2795 device_param->pws_buf[i].pw_len = 4 + (i & 3);
2796 }
2797
2798 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);
2799
2800 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2801 {
2802 run_kernel_amp (device_param, kernel_power);
2803 }
2804
2805 // caching run
2806
2807 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2808 {
2809 run_kernel (KERN_RUN_1, device_param, kernel_power, false);
2810 }
2811 else
2812 {
2813 run_kernel (KERN_RUN_2, device_param, kernel_power, false);
2814 }
2815
2816 // now user repeats
2817
2818 for (int i = 0; i < repeat; i++)
2819 {
2820 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2821 {
2822 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2823 }
2824 else
2825 {
2826 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2827 }
2828 }
2829
2830 const double exec_ms_prev = get_avg_exec_time (device_param, repeat);
2831
2832 // reset fake words
2833
2834 memset (device_param->pws_buf, 0, kernel_power * sizeof (pw_t));
2835
2836 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);
2837 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);
2838
2839 return exec_ms_prev;
2840 }
2841
2842 static void autotune (hc_device_param_t *device_param)
2843 {
2844 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2845
2846 const u32 kernel_accel_min = device_param->kernel_accel_min;
2847 const u32 kernel_accel_max = device_param->kernel_accel_max;
2848
2849 const u32 kernel_loops_min = device_param->kernel_loops_min;
2850 const u32 kernel_loops_max = device_param->kernel_loops_max;
2851
2852 u32 kernel_accel = kernel_accel_min;
2853 u32 kernel_loops = kernel_loops_min;
2854
2855 // steps
2856
2857 #define STEPS_CNT 10
2858
2859 #define STEPS_ACCEL_CNT (STEPS_CNT + 2)
2860 #define STEPS_LOOPS_CNT (STEPS_CNT + 2)
2861
2862 u32 steps_accel[STEPS_ACCEL_CNT];
2863 u32 steps_loops[STEPS_LOOPS_CNT];
2864
2865 for (int i = 0; i < STEPS_ACCEL_CNT; i++)
2866 {
2867 steps_accel[i] = 1 << i;
2868 }
2869
2870 for (int i = 0; i < STEPS_LOOPS_CNT; i++)
2871 {
2872 steps_loops[i] = 1 << i;
2873 }
2874
2875 steps_accel[STEPS_CNT + 0] = kernel_accel_min;
2876 steps_accel[STEPS_CNT + 1] = kernel_accel_max;
2877
2878 steps_loops[STEPS_CNT + 0] = kernel_loops_min;
2879 steps_loops[STEPS_CNT + 1] = kernel_loops_max;
2880
2881 qsort (steps_accel, STEPS_ACCEL_CNT, sizeof (u32), sort_by_u32);
2882 qsort (steps_loops, STEPS_LOOPS_CNT, sizeof (u32), sort_by_u32);
2883
2884 // find out highest kernel-loops that stays below target_ms, we can use it later for multiplication as this is a linear function
2885
2886 u32 kernel_loops_tmp;
2887
2888 for (kernel_loops_tmp = kernel_loops_max; kernel_loops_tmp > kernel_loops_min; kernel_loops_tmp >>= 1)
2889 {
2890 const double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops_tmp, 1);
2891
2892 if (exec_ms < target_ms) break;
2893 }
2894
2895 // kernel-accel
2896
2897 if (kernel_accel_min < kernel_accel_max)
2898 {
2899 double e_best = 0;
2900
2901 for (int i = 0; i < STEPS_ACCEL_CNT; i++)
2902 {
2903 const u32 kernel_accel_try = steps_accel[i];
2904
2905 if (kernel_accel_try < kernel_accel_min) continue;
2906 if (kernel_accel_try > kernel_accel_max) break;
2907
2908 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_tmp, 1);
2909
2910 if (exec_ms > target_ms) break;
2911
2912 const double e = kernel_accel_try / exec_ms;
2913
2914 if (e > e_best)
2915 {
2916 kernel_accel = kernel_accel_try;
2917
2918 e_best = e;
2919 }
2920 }
2921 }
2922
2923 // kernel-loops final
2924
2925 if (kernel_loops_min < kernel_loops_max)
2926 {
2927 double e_best = 0;
2928
2929 for (int i = 0; i < STEPS_LOOPS_CNT; i++)
2930 {
2931 const u32 kernel_loops_try = steps_loops[i];
2932
2933 if (kernel_loops_try < kernel_loops_min) continue;
2934 if (kernel_loops_try > kernel_loops_max) break;
2935
2936 const double exec_ms = try_run (device_param, kernel_accel, kernel_loops_try, 1);
2937
2938 if (exec_ms > target_ms) break;
2939
2940 const double e = kernel_loops_try / exec_ms;
2941
2942 if (e > e_best)
2943 {
2944 kernel_loops = kernel_loops_try;
2945
2946 e_best = e;
2947 }
2948 }
2949 }
2950
2951 // final balance
2952
2953 u32 kernel_accel_best = kernel_accel;
2954 u32 kernel_loops_best = kernel_loops;
2955
2956 u32 exec_best = -1;
2957
2958 if ((kernel_accel_min < kernel_accel_max) || (kernel_loops_min < kernel_loops_max))
2959 {
2960 const double exec_ms = try_run (device_param, kernel_accel_best, kernel_loops_best, 1);
2961
2962 exec_best = exec_ms;
2963 }
2964
2965 // reset
2966
2967 if (kernel_accel_min < kernel_accel_max)
2968 {
2969 u32 kernel_accel_try = kernel_accel;
2970 u32 kernel_loops_try = kernel_loops;
2971
2972 for (int i = 0; i < 2; i++)
2973 {
2974 kernel_accel_try >>= 1;
2975 kernel_loops_try <<= 1;
2976
2977 if (kernel_accel_try < kernel_accel_min) break;
2978 if (kernel_loops_try > kernel_loops_max) break;
2979
2980 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
2981
2982 if (exec_ms < exec_best)
2983 {
2984 kernel_accel_best = kernel_accel_try;
2985 kernel_loops_best = kernel_loops_try;
2986
2987 exec_best = exec_ms;
2988 }
2989 }
2990 }
2991
2992 // reset
2993
2994 if (kernel_loops_min < kernel_loops_max)
2995 {
2996 u32 kernel_accel_try = kernel_accel;
2997 u32 kernel_loops_try = kernel_loops;
2998
2999 for (int i = 0; i < 2; i++)
3000 {
3001 kernel_accel_try <<= 1;
3002 kernel_loops_try >>= 1;
3003
3004 if (kernel_accel_try > kernel_accel_max) break;
3005 if (kernel_loops_try < kernel_loops_min) break;
3006
3007 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
3008
3009 if (exec_ms < exec_best)
3010 {
3011 kernel_accel_best = kernel_accel_try;
3012 kernel_loops_best = kernel_loops_try;
3013
3014 exec_best = exec_ms;
3015 }
3016 }
3017 }
3018
3019 // reset timer
3020
3021 device_param->exec_pos = 0;
3022
3023 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3024
3025 // store
3026
3027 kernel_accel = kernel_accel_best;
3028 kernel_loops = kernel_loops_best;
3029
3030 device_param->kernel_accel = kernel_accel;
3031 device_param->kernel_loops = kernel_loops;
3032
3033 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3034
3035 device_param->kernel_power = kernel_power;
3036
3037 #ifdef DEBUG
3038
3039 if (data.quiet == 0)
3040 {
3041 clear_prompt ();
3042
3043 log_info ("Device #%u: autotuned kernel-accel to %u\n"
3044 "Device #%u: autotuned kernel-loops to %u\n",
3045 device_param->device_id + 1,
3046 kernel_accel,
3047 device_param->device_id + 1,
3048 kernel_loops);
3049
3050 fprintf (stdout, "%s", PROMPT);
3051 fflush (stdout);
3052 }
3053
3054 #endif
3055 }
3056
3057 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3058 {
3059 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3060
3061 // init speed timer
3062
3063 uint speed_pos = device_param->speed_pos;
3064
3065 #ifdef _POSIX
3066 if (device_param->timer_speed.tv_sec == 0)
3067 {
3068 hc_timer_set (&device_param->timer_speed);
3069 }
3070 #endif
3071
3072 #ifdef _WIN
3073 if (device_param->timer_speed.QuadPart == 0)
3074 {
3075 hc_timer_set (&device_param->timer_speed);
3076 }
3077 #endif
3078
3079 // find higest password length, this is for optimization stuff
3080
3081 uint highest_pw_len = 0;
3082
3083 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3084 {
3085 }
3086 else if (data.attack_kern == ATTACK_KERN_COMBI)
3087 {
3088 }
3089 else if (data.attack_kern == ATTACK_KERN_BF)
3090 {
3091 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3092 + device_param->kernel_params_mp_l_buf32[5];
3093 }
3094
3095 // iteration type
3096
3097 uint innerloop_step = 0;
3098 uint innerloop_cnt = 0;
3099
3100 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3101 else innerloop_step = 1;
3102
3103 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3104 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3105 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3106
3107 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3108
3109 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3110 {
3111 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3112
3113 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3114
3115 if (data.devices_status == STATUS_CRACKED) break;
3116 if (data.devices_status == STATUS_ABORTED) break;
3117 if (data.devices_status == STATUS_QUIT) break;
3118 if (data.devices_status == STATUS_BYPASS) break;
3119
3120 salt_t *salt_buf = &data.salts_buf[salt_pos];
3121
3122 device_param->kernel_params_buf32[24] = salt_pos;
3123 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3124 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3125
3126 FILE *combs_fp = device_param->combs_fp;
3127
3128 if (data.attack_mode == ATTACK_MODE_COMBI)
3129 {
3130 rewind (combs_fp);
3131 }
3132
3133 // innerloops
3134
3135 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3136 {
3137 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3138
3139 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3140
3141 if (data.devices_status == STATUS_CRACKED) break;
3142 if (data.devices_status == STATUS_ABORTED) break;
3143 if (data.devices_status == STATUS_QUIT) break;
3144 if (data.devices_status == STATUS_BYPASS) break;
3145
3146 uint innerloop_left = innerloop_cnt - innerloop_pos;
3147
3148 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3149
3150 device_param->innerloop_pos = innerloop_pos;
3151 device_param->innerloop_left = innerloop_left;
3152
3153 device_param->kernel_params_buf32[27] = innerloop_left;
3154
3155 // i think we can get rid of this
3156 if (innerloop_left == 0)
3157 {
3158 puts ("bug, how should this happen????\n");
3159
3160 continue;
3161 }
3162
3163 if (data.salts_shown[salt_pos] == 1)
3164 {
3165 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3166
3167 continue;
3168 }
3169
3170 // initialize amplifiers
3171
3172 if (data.attack_mode == ATTACK_MODE_COMBI)
3173 {
3174 uint i = 0;
3175
3176 while (i < innerloop_left)
3177 {
3178 if (feof (combs_fp)) break;
3179
3180 int line_len = fgetl (combs_fp, line_buf);
3181
3182 if (line_len >= PW_MAX1) continue;
3183
3184 line_len = convert_from_hex (line_buf, line_len);
3185
3186 char *line_buf_new = line_buf;
3187
3188 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3189 {
3190 char rule_buf_out[BLOCK_SIZE] = { 0 };
3191
3192 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3193
3194 if (rule_len_out < 0)
3195 {
3196 data.words_progress_rejected[salt_pos] += pws_cnt;
3197
3198 continue;
3199 }
3200
3201 line_len = rule_len_out;
3202
3203 line_buf_new = rule_buf_out;
3204 }
3205
3206 line_len = MIN (line_len, PW_DICTMAX);
3207
3208 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3209
3210 memcpy (ptr, line_buf_new, line_len);
3211
3212 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3213
3214 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3215 {
3216 uppercase (ptr, line_len);
3217 }
3218
3219 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3220 {
3221 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3222 {
3223 ptr[line_len] = 0x80;
3224 }
3225
3226 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3227 {
3228 ptr[line_len] = 0x01;
3229 }
3230 }
3231
3232 device_param->combs_buf[i].pw_len = line_len;
3233
3234 i++;
3235 }
3236
3237 for (uint j = i; j < innerloop_left; j++)
3238 {
3239 device_param->combs_buf[j].i[0] = 0;
3240 device_param->combs_buf[j].i[1] = 0;
3241 device_param->combs_buf[j].i[2] = 0;
3242 device_param->combs_buf[j].i[3] = 0;
3243 device_param->combs_buf[j].i[4] = 0;
3244 device_param->combs_buf[j].i[5] = 0;
3245 device_param->combs_buf[j].i[6] = 0;
3246 device_param->combs_buf[j].i[7] = 0;
3247
3248 device_param->combs_buf[j].pw_len = 0;
3249 }
3250
3251 innerloop_left = i;
3252 }
3253 else if (data.attack_mode == ATTACK_MODE_BF)
3254 {
3255 u64 off = innerloop_pos;
3256
3257 device_param->kernel_params_mp_r_buf64[3] = off;
3258
3259 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3260 }
3261 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3262 {
3263 u64 off = innerloop_pos;
3264
3265 device_param->kernel_params_mp_buf64[3] = off;
3266
3267 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3268 }
3269 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3270 {
3271 u64 off = innerloop_pos;
3272
3273 device_param->kernel_params_mp_buf64[3] = off;
3274
3275 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3276 }
3277
3278 // copy amplifiers
3279
3280 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3281 {
3282 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);
3283 }
3284 else if (data.attack_mode == ATTACK_MODE_COMBI)
3285 {
3286 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);
3287 }
3288 else if (data.attack_mode == ATTACK_MODE_BF)
3289 {
3290 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);
3291 }
3292 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3293 {
3294 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);
3295 }
3296 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3297 {
3298 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);
3299 }
3300
3301 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3302
3303 if (data.benchmark == 1)
3304 {
3305 for (u32 i = 0; i < data.benchmark_repeats; i++)
3306 {
3307 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3308 }
3309 }
3310
3311 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3312
3313 if (data.devices_status == STATUS_CRACKED) break;
3314 if (data.devices_status == STATUS_ABORTED) break;
3315 if (data.devices_status == STATUS_QUIT) break;
3316
3317 /**
3318 * result
3319 */
3320
3321 hc_thread_mutex_lock (mux_display);
3322
3323 check_cracked (device_param, salt_pos);
3324
3325 hc_thread_mutex_unlock (mux_display);
3326
3327 /**
3328 * progress
3329 */
3330
3331 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3332
3333 if (data.benchmark == 1)
3334 {
3335 perf_sum_all = (perf_sum_all * data.benchmark_repeats) + perf_sum_all;
3336 }
3337
3338 hc_thread_mutex_lock (mux_counter);
3339
3340 data.words_progress_done[salt_pos] += perf_sum_all;
3341
3342 hc_thread_mutex_unlock (mux_counter);
3343
3344 /**
3345 * speed
3346 */
3347
3348 float speed_ms;
3349
3350 hc_timer_get (device_param->timer_speed, speed_ms);
3351
3352 hc_timer_set (&device_param->timer_speed);
3353
3354 hc_thread_mutex_lock (mux_display);
3355
3356 device_param->speed_cnt[speed_pos] = perf_sum_all;
3357
3358 device_param->speed_ms[speed_pos] = speed_ms;
3359
3360 device_param->speed_rec[speed_pos] = device_param->timer_speed;
3361
3362 hc_thread_mutex_unlock (mux_display);
3363
3364 speed_pos++;
3365
3366 if (speed_pos == SPEED_CACHE)
3367 {
3368 speed_pos = 0;
3369 }
3370
3371 /**
3372 * benchmark
3373 */
3374
3375 if (data.benchmark == 1) break;
3376 }
3377 }
3378
3379 device_param->speed_pos = speed_pos;
3380
3381 myfree (line_buf);
3382 }
3383
3384 static void load_segment (wl_data_t *wl_data, FILE *fd)
3385 {
3386 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3387
3388 wl_data->pos = 0;
3389
3390 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3391
3392 wl_data->buf[wl_data->cnt] = 0;
3393
3394 if (wl_data->cnt == 0) return;
3395
3396 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3397
3398 while (!feof (fd))
3399 {
3400 if (wl_data->cnt == wl_data->avail)
3401 {
3402 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3403
3404 wl_data->avail += wl_data->incr;
3405 }
3406
3407 const int c = fgetc (fd);
3408
3409 if (c == EOF) break;
3410
3411 wl_data->buf[wl_data->cnt] = (char) c;
3412
3413 wl_data->cnt++;
3414
3415 if (c == '\n') break;
3416 }
3417
3418 // ensure stream ends with a newline
3419
3420 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3421 {
3422 wl_data->cnt++;
3423
3424 wl_data->buf[wl_data->cnt - 1] = '\n';
3425 }
3426
3427 return;
3428 }
3429
3430 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3431 {
3432 char *ptr = buf;
3433
3434 for (u32 i = 0; i < sz; i++, ptr++)
3435 {
3436 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3437
3438 if (i == 7)
3439 {
3440 *off = i;
3441 *len = i;
3442
3443 return;
3444 }
3445
3446 if (*ptr != '\n') continue;
3447
3448 *off = i + 1;
3449
3450 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3451
3452 *len = i;
3453
3454 return;
3455 }
3456
3457 *off = sz;
3458 *len = sz;
3459 }
3460
3461 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3462 {
3463 char *ptr = buf;
3464
3465 for (u32 i = 0; i < sz; i++, ptr++)
3466 {
3467 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3468
3469 if (*ptr != '\n') continue;
3470
3471 *off = i + 1;
3472
3473 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3474
3475 *len = i;
3476
3477 return;
3478 }
3479
3480 *off = sz;
3481 *len = sz;
3482 }
3483
3484 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3485 {
3486 char *ptr = buf;
3487
3488 for (u32 i = 0; i < sz; i++, ptr++)
3489 {
3490 if (*ptr != '\n') continue;
3491
3492 *off = i + 1;
3493
3494 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3495
3496 *len = i;
3497
3498 return;
3499 }
3500
3501 *off = sz;
3502 *len = sz;
3503 }
3504
3505 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3506 {
3507 while (wl_data->pos < wl_data->cnt)
3508 {
3509 uint off;
3510 uint len;
3511
3512 char *ptr = wl_data->buf + wl_data->pos;
3513
3514 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3515
3516 wl_data->pos += off;
3517
3518 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3519 {
3520 char rule_buf_out[BLOCK_SIZE] = { 0 };
3521
3522 int rule_len_out = -1;
3523
3524 if (len < BLOCK_SIZE)
3525 {
3526 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3527 }
3528
3529 if (rule_len_out < 0)
3530 {
3531 continue;
3532 }
3533
3534 if (rule_len_out > PW_MAX)
3535 {
3536 continue;
3537 }
3538 }
3539 else
3540 {
3541 if (len > PW_MAX)
3542 {
3543 continue;
3544 }
3545 }
3546
3547 *out_buf = ptr;
3548 *out_len = len;
3549
3550 return;
3551 }
3552
3553 if (feof (fd))
3554 {
3555 fprintf (stderr, "BUG feof()!!\n");
3556
3557 return;
3558 }
3559
3560 load_segment (wl_data, fd);
3561
3562 get_next_word (wl_data, fd, out_buf, out_len);
3563 }
3564
3565 #ifdef _POSIX
3566 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3567 #endif
3568
3569 #ifdef _WIN
3570 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3571 #endif
3572 {
3573 hc_signal (NULL);
3574
3575 dictstat_t d;
3576
3577 d.cnt = 0;
3578
3579 #ifdef _POSIX
3580 fstat (fileno (fd), &d.stat);
3581 #endif
3582
3583 #ifdef _WIN
3584 _fstat64 (fileno (fd), &d.stat);
3585 #endif
3586
3587 d.stat.st_mode = 0;
3588 d.stat.st_nlink = 0;
3589 d.stat.st_uid = 0;
3590 d.stat.st_gid = 0;
3591 d.stat.st_rdev = 0;
3592 d.stat.st_atime = 0;
3593
3594 #ifdef _POSIX
3595 d.stat.st_blksize = 0;
3596 d.stat.st_blocks = 0;
3597 #endif
3598
3599 if (d.stat.st_size == 0) return 0;
3600
3601 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3602
3603 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3604 {
3605 if (d_cache)
3606 {
3607 u64 cnt = d_cache->cnt;
3608
3609 u64 keyspace = cnt;
3610
3611 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3612 {
3613 keyspace *= data.kernel_rules_cnt;
3614 }
3615 else if (data.attack_kern == ATTACK_KERN_COMBI)
3616 {
3617 keyspace *= data.combs_cnt;
3618 }
3619
3620 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);
3621 if (data.quiet == 0) log_info ("");
3622
3623 hc_signal (sigHandler_default);
3624
3625 return (keyspace);
3626 }
3627 }
3628
3629 time_t now = 0;
3630 time_t prev = 0;
3631
3632 u64 comp = 0;
3633 u64 cnt = 0;
3634 u64 cnt2 = 0;
3635
3636 while (!feof (fd))
3637 {
3638 load_segment (wl_data, fd);
3639
3640 comp += wl_data->cnt;
3641
3642 u32 i = 0;
3643
3644 while (i < wl_data->cnt)
3645 {
3646 u32 len;
3647 u32 off;
3648
3649 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3650
3651 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3652 {
3653 char rule_buf_out[BLOCK_SIZE] = { 0 };
3654
3655 int rule_len_out = -1;
3656
3657 if (len < BLOCK_SIZE)
3658 {
3659 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3660 }
3661
3662 if (rule_len_out < 0)
3663 {
3664 len = PW_MAX1;
3665 }
3666 else
3667 {
3668 len = rule_len_out;
3669 }
3670 }
3671
3672 if (len < PW_MAX1)
3673 {
3674 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3675 {
3676 cnt += data.kernel_rules_cnt;
3677 }
3678 else if (data.attack_kern == ATTACK_KERN_COMBI)
3679 {
3680 cnt += data.combs_cnt;
3681 }
3682
3683 d.cnt++;
3684 }
3685
3686 i += off;
3687
3688 cnt2++;
3689 }
3690
3691 time (&now);
3692
3693 if ((now - prev) == 0) continue;
3694
3695 float percent = (float) comp / (float) d.stat.st_size;
3696
3697 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);
3698
3699 time (&prev);
3700 }
3701
3702 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);
3703 if (data.quiet == 0) log_info ("");
3704
3705 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3706
3707 hc_signal (sigHandler_default);
3708
3709 return (cnt);
3710 }
3711
3712 static void *thread_monitor (void *p)
3713 {
3714 uint runtime_check = 0;
3715 uint remove_check = 0;
3716 uint status_check = 0;
3717 uint restore_check = 0;
3718
3719 uint restore_left = data.restore_timer;
3720 uint remove_left = data.remove_timer;
3721 uint status_left = data.status_timer;
3722
3723 #ifdef HAVE_HWMON
3724 uint hwmon_check = 0;
3725
3726 // these variables are mainly used for fan control (AMD only)
3727
3728 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3729
3730 // temperature controller "loopback" values
3731
3732 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3733 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3734
3735 #ifdef HAVE_ADL
3736 int temp_threshold = 1; // degrees celcius
3737
3738 int fan_speed_min = 15; // in percentage
3739 int fan_speed_max = 100;
3740 #endif // HAVE_ADL
3741
3742 time_t last_temp_check_time;
3743 #endif // HAVE_HWMON
3744
3745 uint sleep_time = 1;
3746
3747 if (data.runtime)
3748 {
3749 runtime_check = 1;
3750 }
3751
3752 if (data.restore_timer)
3753 {
3754 restore_check = 1;
3755 }
3756
3757 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3758 {
3759 remove_check = 1;
3760 }
3761
3762 if (data.status == 1)
3763 {
3764 status_check = 1;
3765 }
3766
3767 #ifdef HAVE_HWMON
3768 if (data.gpu_temp_disable == 0)
3769 {
3770 time (&last_temp_check_time);
3771
3772 hwmon_check = 1;
3773 }
3774 #endif
3775
3776 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3777 {
3778 #ifdef HAVE_HWMON
3779 if (hwmon_check == 0)
3780 #endif
3781 return (p);
3782 }
3783
3784 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3785 {
3786 hc_sleep (sleep_time);
3787
3788 if (data.devices_status != STATUS_RUNNING) continue;
3789
3790 #ifdef HAVE_HWMON
3791 if (hwmon_check == 1)
3792 {
3793 hc_thread_mutex_lock (mux_adl);
3794
3795 time_t temp_check_time;
3796
3797 time (&temp_check_time);
3798
3799 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3800
3801 if (Ta == 0) Ta = 1;
3802
3803 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3804 {
3805 hc_device_param_t *device_param = &data.devices_param[device_id];
3806
3807 if (device_param->skipped) continue;
3808
3809 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3810
3811 const int temperature = hm_get_temperature_with_device_id (device_id);
3812
3813 if (temperature > (int) data.gpu_temp_abort)
3814 {
3815 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3816
3817 if (data.devices_status != STATUS_QUIT) myabort ();
3818
3819 break;
3820 }
3821
3822 #ifdef HAVE_ADL
3823 const int gpu_temp_retain = data.gpu_temp_retain;
3824
3825 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3826 {
3827 if (data.hm_device[device_id].fan_supported == 1)
3828 {
3829 int temp_cur = temperature;
3830
3831 int temp_diff_new = gpu_temp_retain - temp_cur;
3832
3833 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3834
3835 // calculate Ta value (time difference in seconds between the last check and this check)
3836
3837 last_temp_check_time = temp_check_time;
3838
3839 float Kp = 1.8;
3840 float Ki = 0.005;
3841 float Kd = 6;
3842
3843 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3844
3845 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);
3846
3847 if (abs (fan_diff_required) >= temp_threshold)
3848 {
3849 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3850
3851 int fan_speed_level = fan_speed_cur;
3852
3853 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3854
3855 int fan_speed_new = fan_speed_level - fan_diff_required;
3856
3857 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3858 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3859
3860 if (fan_speed_new != fan_speed_cur)
3861 {
3862 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3863 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3864
3865 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3866 {
3867 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3868
3869 fan_speed_chgd[device_id] = 1;
3870 }
3871
3872 temp_diff_old[device_id] = temp_diff_new;
3873 }
3874 }
3875 }
3876 }
3877 #endif // HAVE_ADL
3878 }
3879
3880 hc_thread_mutex_unlock (mux_adl);
3881 }
3882 #endif // HAVE_HWMON
3883
3884 if (restore_check == 1)
3885 {
3886 restore_left--;
3887
3888 if (restore_left == 0)
3889 {
3890 if (data.restore_disable == 0) cycle_restore ();
3891
3892 restore_left = data.restore_timer;
3893 }
3894 }
3895
3896 if ((runtime_check == 1) && (data.runtime_start > 0))
3897 {
3898 time_t runtime_cur;
3899
3900 time (&runtime_cur);
3901
3902 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3903
3904 if (runtime_left <= 0)
3905 {
3906 if (data.benchmark == 0)
3907 {
3908 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3909 }
3910
3911 if (data.devices_status != STATUS_QUIT) myabort ();
3912 }
3913 }
3914
3915 if (remove_check == 1)
3916 {
3917 remove_left--;
3918
3919 if (remove_left == 0)
3920 {
3921 if (data.digests_saved != data.digests_done)
3922 {
3923 data.digests_saved = data.digests_done;
3924
3925 save_hash ();
3926 }
3927
3928 remove_left = data.remove_timer;
3929 }
3930 }
3931
3932 if (status_check == 1)
3933 {
3934 status_left--;
3935
3936 if (status_left == 0)
3937 {
3938 hc_thread_mutex_lock (mux_display);
3939
3940 if (data.quiet == 0) clear_prompt ();
3941
3942 if (data.quiet == 0) log_info ("");
3943
3944 status_display ();
3945
3946 if (data.quiet == 0) log_info ("");
3947
3948 hc_thread_mutex_unlock (mux_display);
3949
3950 status_left = data.status_timer;
3951 }
3952 }
3953 }
3954
3955 #ifdef HAVE_HWMON
3956 myfree (fan_speed_chgd);
3957
3958 myfree (temp_diff_old);
3959 myfree (temp_diff_sum);
3960 #endif
3961
3962 p = NULL;
3963
3964 return (p);
3965 }
3966
3967 static void *thread_outfile_remove (void *p)
3968 {
3969 // some hash-dependent constants
3970 char *outfile_dir = data.outfile_check_directory;
3971 uint dgst_size = data.dgst_size;
3972 uint isSalted = data.isSalted;
3973 uint esalt_size = data.esalt_size;
3974 uint hash_mode = data.hash_mode;
3975
3976 uint outfile_check_timer = data.outfile_check_timer;
3977
3978 char separator = data.separator;
3979
3980 // some hash-dependent functions
3981 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3982 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3983
3984 // buffers
3985 hash_t hash_buf = { 0, 0, 0, 0, 0 };
3986
3987 hash_buf.digest = mymalloc (dgst_size);
3988
3989 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3990
3991 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3992
3993 uint digest_buf[64] = { 0 };
3994
3995 outfile_data_t *out_info = NULL;
3996
3997 char **out_files = NULL;
3998
3999 time_t folder_mtime = 0;
4000
4001 int out_cnt = 0;
4002
4003 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4004
4005 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4006 {
4007 hc_sleep (1);
4008
4009 if (data.devices_status != STATUS_RUNNING) continue;
4010
4011 check_left--;
4012
4013 if (check_left == 0)
4014 {
4015 struct stat outfile_check_stat;
4016
4017 if (stat (outfile_dir, &outfile_check_stat) == 0)
4018 {
4019 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4020
4021 if (is_dir == 1)
4022 {
4023 if (outfile_check_stat.st_mtime > folder_mtime)
4024 {
4025 char **out_files_new = scan_directory (outfile_dir);
4026
4027 int out_cnt_new = count_dictionaries (out_files_new);
4028
4029 outfile_data_t *out_info_new = NULL;
4030
4031 if (out_cnt_new > 0)
4032 {
4033 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4034
4035 for (int i = 0; i < out_cnt_new; i++)
4036 {
4037 out_info_new[i].file_name = out_files_new[i];
4038
4039 // check if there are files that we have seen/checked before (and not changed)
4040
4041 for (int j = 0; j < out_cnt; j++)
4042 {
4043 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4044 {
4045 struct stat outfile_stat;
4046
4047 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4048 {
4049 if (outfile_stat.st_ctime == out_info[j].ctime)
4050 {
4051 out_info_new[i].ctime = out_info[j].ctime;
4052 out_info_new[i].seek = out_info[j].seek;
4053 }
4054 }
4055 }
4056 }
4057 }
4058 }
4059
4060 local_free (out_info);
4061 local_free (out_files);
4062
4063 out_files = out_files_new;
4064 out_cnt = out_cnt_new;
4065 out_info = out_info_new;
4066
4067 folder_mtime = outfile_check_stat.st_mtime;
4068 }
4069
4070 for (int j = 0; j < out_cnt; j++)
4071 {
4072 FILE *fp = fopen (out_info[j].file_name, "rb");
4073
4074 if (fp != NULL)
4075 {
4076 //hc_thread_mutex_lock (mux_display);
4077
4078 #ifdef _POSIX
4079 struct stat outfile_stat;
4080
4081 fstat (fileno (fp), &outfile_stat);
4082 #endif
4083
4084 #ifdef _WIN
4085 struct stat64 outfile_stat;
4086
4087 _fstat64 (fileno (fp), &outfile_stat);
4088 #endif
4089
4090 if (outfile_stat.st_ctime > out_info[j].ctime)
4091 {
4092 out_info[j].ctime = outfile_stat.st_ctime;
4093 out_info[j].seek = 0;
4094 }
4095
4096 fseek (fp, out_info[j].seek, SEEK_SET);
4097
4098 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4099
4100 while (!feof (fp))
4101 {
4102 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4103
4104 if (ptr == NULL) break;
4105
4106 int line_len = strlen (line_buf);
4107
4108 if (line_len <= 0) continue;
4109
4110 int iter = MAX_CUT_TRIES;
4111
4112 for (uint i = line_len - 1; i && iter; i--, line_len--)
4113 {
4114 if (line_buf[i] != separator) continue;
4115
4116 int parser_status = PARSER_OK;
4117
4118 if ((hash_mode != 2500) && (hash_mode != 6800))
4119 {
4120 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4121 }
4122
4123 uint found = 0;
4124
4125 if (parser_status == PARSER_OK)
4126 {
4127 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4128 {
4129 if (data.salts_shown[salt_pos] == 1) continue;
4130
4131 salt_t *salt_buf = &data.salts_buf[salt_pos];
4132
4133 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4134 {
4135 uint idx = salt_buf->digests_offset + digest_pos;
4136
4137 if (data.digests_shown[idx] == 1) continue;
4138
4139 uint cracked = 0;
4140
4141 if (hash_mode == 6800)
4142 {
4143 if (i == salt_buf->salt_len)
4144 {
4145 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4146 }
4147 }
4148 else if (hash_mode == 2500)
4149 {
4150 // BSSID : MAC1 : MAC2 (:plain)
4151 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4152 {
4153 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4154
4155 if (!cracked) continue;
4156
4157 // now compare MAC1 and MAC2 too, since we have this additional info
4158 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4159 char *mac2_pos = mac1_pos + 12 + 1;
4160
4161 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4162 wpa_t *wpa = &wpas[salt_pos];
4163
4164 // compare hex string(s) vs binary MAC address(es)
4165
4166 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4167 {
4168 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4169 {
4170 cracked = 0;
4171
4172 break;
4173 }
4174 }
4175
4176 // early skip ;)
4177 if (!cracked) continue;
4178
4179 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4180 {
4181 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4182 {
4183 cracked = 0;
4184
4185 break;
4186 }
4187 }
4188 }
4189 }
4190 else
4191 {
4192 char *digests_buf_ptr = (char *) data.digests_buf;
4193
4194 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4195
4196 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4197 }
4198
4199 if (cracked == 1)
4200 {
4201 found = 1;
4202
4203 data.digests_shown[idx] = 1;
4204
4205 data.digests_done++;
4206
4207 salt_buf->digests_done++;
4208
4209 if (salt_buf->digests_done == salt_buf->digests_cnt)
4210 {
4211 data.salts_shown[salt_pos] = 1;
4212
4213 data.salts_done++;
4214
4215 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4216 }
4217 }
4218 }
4219
4220 if (data.devices_status == STATUS_CRACKED) break;
4221 }
4222 }
4223
4224 if (found) break;
4225
4226 if (data.devices_status == STATUS_CRACKED) break;
4227
4228 iter--;
4229 }
4230
4231 if (data.devices_status == STATUS_CRACKED) break;
4232 }
4233
4234 myfree (line_buf);
4235
4236 out_info[j].seek = ftell (fp);
4237
4238 //hc_thread_mutex_unlock (mux_display);
4239
4240 fclose (fp);
4241 }
4242 }
4243 }
4244 }
4245
4246 check_left = outfile_check_timer;
4247 }
4248 }
4249
4250 if (esalt_size) local_free (hash_buf.esalt);
4251
4252 if (isSalted) local_free (hash_buf.salt);
4253
4254 local_free (hash_buf.digest);
4255
4256 local_free (out_info);
4257
4258 local_free (out_files);
4259
4260 p = NULL;
4261
4262 return (p);
4263 }
4264
4265 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4266 {
4267 if (device_param->pws_cnt < device_param->kernel_power)
4268 {
4269 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4270
4271 u8 *ptr = (u8 *) pw->i;
4272
4273 memcpy (ptr, pw_buf, pw_len);
4274
4275 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4276
4277 pw->pw_len = pw_len;
4278
4279 device_param->pws_cnt++;
4280 }
4281 else
4282 {
4283 fprintf (stderr, "BUG pw_add()!!\n");
4284
4285 return;
4286 }
4287 }
4288
4289 static uint get_work (hc_device_param_t *device_param, const u64 max, const bool allow_div)
4290 {
4291 hc_thread_mutex_lock (mux_dispatcher);
4292
4293 const u64 words_cur = data.words_cur;
4294 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4295
4296 device_param->words_off = words_cur;
4297
4298 const u64 words_left = words_base - words_cur;
4299
4300 if (allow_div)
4301 {
4302 if (data.kernel_power_all > words_left)
4303 {
4304 if (data.kernel_power_div == 0)
4305 {
4306 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4307 }
4308 }
4309
4310 if (data.kernel_power_div)
4311 {
4312 if (device_param->kernel_power == device_param->kernel_power_user)
4313 {
4314 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4315
4316 if (kernel_power_new < device_param->kernel_power)
4317 {
4318 device_param->kernel_power = kernel_power_new;
4319 }
4320 }
4321 }
4322 }
4323
4324 const uint kernel_power = device_param->kernel_power;
4325
4326 uint work = MIN (words_left, kernel_power);
4327
4328 work = MIN (work, max);
4329
4330 data.words_cur += work;
4331
4332 hc_thread_mutex_unlock (mux_dispatcher);
4333
4334 return work;
4335 }
4336
4337 static void *thread_calc_stdin (void *p)
4338 {
4339 hc_device_param_t *device_param = (hc_device_param_t *) p;
4340
4341 if (device_param->skipped) return NULL;
4342
4343 autotune (device_param);
4344
4345 char *buf = (char *) mymalloc (HCBUFSIZ);
4346
4347 const uint attack_kern = data.attack_kern;
4348
4349 const uint kernel_power = device_param->kernel_power;
4350
4351 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4352 {
4353 hc_thread_mutex_lock (mux_dispatcher);
4354
4355 if (feof (stdin) != 0)
4356 {
4357 hc_thread_mutex_unlock (mux_dispatcher);
4358
4359 break;
4360 }
4361
4362 uint words_cur = 0;
4363
4364 while (words_cur < kernel_power)
4365 {
4366 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4367
4368 if (line_buf == NULL) break;
4369
4370 uint line_len = in_superchop (line_buf);
4371
4372 line_len = convert_from_hex (line_buf, line_len);
4373
4374 // post-process rule engine
4375
4376 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4377 {
4378 char rule_buf_out[BLOCK_SIZE] = { 0 };
4379
4380 int rule_len_out = -1;
4381
4382 if (line_len < BLOCK_SIZE)
4383 {
4384 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4385 }
4386
4387 if (rule_len_out < 0) continue;
4388
4389 line_buf = rule_buf_out;
4390 line_len = rule_len_out;
4391 }
4392
4393 if (line_len > PW_MAX)
4394 {
4395 continue;
4396 }
4397
4398 if (attack_kern == ATTACK_KERN_STRAIGHT)
4399 {
4400 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4401 {
4402 hc_thread_mutex_lock (mux_counter);
4403
4404 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4405 {
4406 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4407 }
4408
4409 hc_thread_mutex_unlock (mux_counter);
4410
4411 continue;
4412 }
4413 }
4414 else if (attack_kern == ATTACK_KERN_COMBI)
4415 {
4416 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4417 // since we still need to combine the plains
4418
4419 if (line_len > data.pw_max)
4420 {
4421 hc_thread_mutex_lock (mux_counter);
4422
4423 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4424 {
4425 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4426 }
4427
4428 hc_thread_mutex_unlock (mux_counter);
4429
4430 continue;
4431 }
4432 }
4433
4434 pw_add (device_param, (u8 *) line_buf, line_len);
4435
4436 words_cur++;
4437
4438 if (data.devices_status == STATUS_CRACKED) break;
4439 if (data.devices_status == STATUS_ABORTED) break;
4440 if (data.devices_status == STATUS_QUIT) break;
4441 if (data.devices_status == STATUS_BYPASS) break;
4442 }
4443
4444 hc_thread_mutex_unlock (mux_dispatcher);
4445
4446 if (data.devices_status == STATUS_CRACKED) break;
4447 if (data.devices_status == STATUS_ABORTED) break;
4448 if (data.devices_status == STATUS_QUIT) break;
4449 if (data.devices_status == STATUS_BYPASS) break;
4450
4451 // flush
4452
4453 const uint pws_cnt = device_param->pws_cnt;
4454
4455 if (pws_cnt)
4456 {
4457 run_copy (device_param, pws_cnt);
4458
4459 run_cracker (device_param, pws_cnt);
4460
4461 device_param->pws_cnt = 0;
4462
4463 if (attack_kern == ATTACK_KERN_STRAIGHT)
4464 {
4465 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4466 }
4467 else if (attack_kern == ATTACK_KERN_COMBI)
4468 {
4469 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4470 }
4471 }
4472 }
4473
4474 device_param->kernel_accel = 0;
4475 device_param->kernel_loops = 0;
4476
4477 myfree (buf);
4478
4479 return NULL;
4480 }
4481
4482 static void *thread_calc (void *p)
4483 {
4484 hc_device_param_t *device_param = (hc_device_param_t *) p;
4485
4486 if (device_param->skipped) return NULL;
4487
4488 autotune (device_param);
4489
4490 const uint attack_mode = data.attack_mode;
4491 const uint attack_kern = data.attack_kern;
4492
4493 if (attack_mode == ATTACK_MODE_BF)
4494 {
4495 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4496 {
4497 const uint work = get_work (device_param, -1, true);
4498
4499 if (work == 0) break;
4500
4501 const u64 words_off = device_param->words_off;
4502 const u64 words_fin = words_off + work;
4503
4504 const uint pws_cnt = work;
4505
4506 device_param->pws_cnt = pws_cnt;
4507
4508 if (pws_cnt)
4509 {
4510 run_copy (device_param, pws_cnt);
4511
4512 run_cracker (device_param, pws_cnt);
4513
4514 device_param->pws_cnt = 0;
4515
4516 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4517 }
4518
4519 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4520
4521 if (data.devices_status == STATUS_CRACKED) break;
4522 if (data.devices_status == STATUS_ABORTED) break;
4523 if (data.devices_status == STATUS_QUIT) break;
4524 if (data.devices_status == STATUS_BYPASS) break;
4525
4526 if (data.benchmark == 1) break;
4527
4528 device_param->words_done = words_fin;
4529 }
4530 }
4531 else
4532 {
4533 const uint segment_size = data.segment_size;
4534
4535 char *dictfile = data.dictfile;
4536
4537 if (attack_mode == ATTACK_MODE_COMBI)
4538 {
4539 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4540 {
4541 dictfile = data.dictfile2;
4542 }
4543 }
4544
4545 FILE *fd = fopen (dictfile, "rb");
4546
4547 if (fd == NULL)
4548 {
4549 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4550
4551 return NULL;
4552 }
4553
4554 if (attack_mode == ATTACK_MODE_COMBI)
4555 {
4556 const uint combs_mode = data.combs_mode;
4557
4558 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4559 {
4560 const char *dictfilec = data.dictfile2;
4561
4562 FILE *combs_fp = fopen (dictfilec, "rb");
4563
4564 if (combs_fp == NULL)
4565 {
4566 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4567
4568 fclose (fd);
4569
4570 return NULL;
4571 }
4572
4573 device_param->combs_fp = combs_fp;
4574 }
4575 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4576 {
4577 const char *dictfilec = data.dictfile;
4578
4579 FILE *combs_fp = fopen (dictfilec, "rb");
4580
4581 if (combs_fp == NULL)
4582 {
4583 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4584
4585 fclose (fd);
4586
4587 return NULL;
4588 }
4589
4590 device_param->combs_fp = combs_fp;
4591 }
4592 }
4593
4594 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4595
4596 wl_data->buf = (char *) mymalloc (segment_size);
4597 wl_data->avail = segment_size;
4598 wl_data->incr = segment_size;
4599 wl_data->cnt = 0;
4600 wl_data->pos = 0;
4601
4602 u64 words_cur = 0;
4603
4604 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4605 {
4606 u64 words_off = 0;
4607 u64 words_fin = 0;
4608
4609 bool allow_div = true;
4610
4611 u64 max = -1;
4612
4613 while (max)
4614 {
4615 const uint work = get_work (device_param, max, allow_div);
4616
4617 allow_div = false;
4618
4619 if (work == 0) break;
4620
4621 words_off = device_param->words_off;
4622 words_fin = words_off + work;
4623
4624 char *line_buf;
4625 uint line_len;
4626
4627 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4628
4629 max = 0;
4630
4631 for ( ; words_cur < words_fin; words_cur++)
4632 {
4633 get_next_word (wl_data, fd, &line_buf, &line_len);
4634
4635 line_len = convert_from_hex (line_buf, line_len);
4636
4637 // post-process rule engine
4638
4639 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4640 {
4641 char rule_buf_out[BLOCK_SIZE] = { 0 };
4642
4643 int rule_len_out = -1;
4644
4645 if (line_len < BLOCK_SIZE)
4646 {
4647 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4648 }
4649
4650 if (rule_len_out < 0) continue;
4651
4652 line_buf = rule_buf_out;
4653 line_len = rule_len_out;
4654 }
4655
4656 if (attack_kern == ATTACK_KERN_STRAIGHT)
4657 {
4658 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4659 {
4660 max++;
4661
4662 hc_thread_mutex_lock (mux_counter);
4663
4664 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4665 {
4666 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4667 }
4668
4669 hc_thread_mutex_unlock (mux_counter);
4670
4671 continue;
4672 }
4673 }
4674 else if (attack_kern == ATTACK_KERN_COMBI)
4675 {
4676 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4677 // since we still need to combine the plains
4678
4679 if (line_len > data.pw_max)
4680 {
4681 max++;
4682
4683 hc_thread_mutex_lock (mux_counter);
4684
4685 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4686 {
4687 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4688 }
4689
4690 hc_thread_mutex_unlock (mux_counter);
4691
4692 continue;
4693 }
4694 }
4695
4696 pw_add (device_param, (u8 *) line_buf, line_len);
4697
4698 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4699
4700 if (data.devices_status == STATUS_CRACKED) break;
4701 if (data.devices_status == STATUS_ABORTED) break;
4702 if (data.devices_status == STATUS_QUIT) break;
4703 if (data.devices_status == STATUS_BYPASS) break;
4704 }
4705
4706 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4707
4708 if (data.devices_status == STATUS_CRACKED) break;
4709 if (data.devices_status == STATUS_ABORTED) break;
4710 if (data.devices_status == STATUS_QUIT) break;
4711 if (data.devices_status == STATUS_BYPASS) break;
4712 }
4713
4714 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4715
4716 if (data.devices_status == STATUS_CRACKED) break;
4717 if (data.devices_status == STATUS_ABORTED) break;
4718 if (data.devices_status == STATUS_QUIT) break;
4719 if (data.devices_status == STATUS_BYPASS) break;
4720
4721 //
4722 // flush
4723 //
4724
4725 const uint pws_cnt = device_param->pws_cnt;
4726
4727 if (pws_cnt)
4728 {
4729 run_copy (device_param, pws_cnt);
4730
4731 run_cracker (device_param, pws_cnt);
4732
4733 device_param->pws_cnt = 0;
4734
4735 if (attack_kern == ATTACK_KERN_STRAIGHT)
4736 {
4737 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4738 }
4739 else if (attack_kern == ATTACK_KERN_COMBI)
4740 {
4741 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4742 }
4743 }
4744
4745 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4746
4747 if (data.devices_status == STATUS_CRACKED) break;
4748 if (data.devices_status == STATUS_ABORTED) break;
4749 if (data.devices_status == STATUS_QUIT) break;
4750 if (data.devices_status == STATUS_BYPASS) break;
4751
4752 if (words_fin == 0) break;
4753
4754 device_param->words_done = words_fin;
4755 }
4756
4757 if (attack_mode == ATTACK_MODE_COMBI)
4758 {
4759 fclose (device_param->combs_fp);
4760 }
4761
4762 free (wl_data->buf);
4763 free (wl_data);
4764
4765 fclose (fd);
4766 }
4767
4768 device_param->kernel_accel = 0;
4769 device_param->kernel_loops = 0;
4770
4771 return NULL;
4772 }
4773
4774 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4775 {
4776 if (!device_param)
4777 {
4778 log_error ("ERROR: %s : Invalid argument", __func__);
4779
4780 exit (-1);
4781 }
4782
4783 salt_t *salt_buf = &data.salts_buf[salt_pos];
4784
4785 device_param->kernel_params_buf32[24] = salt_pos;
4786 device_param->kernel_params_buf32[27] = 1;
4787 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4788 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4789 device_param->kernel_params_buf32[30] = 0;
4790 device_param->kernel_params_buf32[31] = 1;
4791
4792 char *dictfile_old = data.dictfile;
4793
4794 const char *weak_hash_check = "weak-hash-check";
4795
4796 data.dictfile = (char *) weak_hash_check;
4797
4798 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4799
4800 data.kernel_rules_buf[0].cmds[0] = 0;
4801
4802 /**
4803 * run the kernel
4804 */
4805
4806 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4807 {
4808 run_kernel (KERN_RUN_1, device_param, 1, false);
4809 }
4810 else
4811 {
4812 run_kernel (KERN_RUN_1, device_param, 1, false);
4813
4814 uint loop_step = 16;
4815
4816 const uint iter = salt_buf->salt_iter;
4817
4818 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4819 {
4820 uint loop_left = iter - loop_pos;
4821
4822 loop_left = MIN (loop_left, loop_step);
4823
4824 device_param->kernel_params_buf32[25] = loop_pos;
4825 device_param->kernel_params_buf32[26] = loop_left;
4826
4827 run_kernel (KERN_RUN_2, device_param, 1, false);
4828 }
4829
4830 run_kernel (KERN_RUN_3, device_param, 1, false);
4831 }
4832
4833 /**
4834 * result
4835 */
4836
4837 check_cracked (device_param, salt_pos);
4838
4839 /**
4840 * cleanup
4841 */
4842
4843 device_param->kernel_params_buf32[24] = 0;
4844 device_param->kernel_params_buf32[25] = 0;
4845 device_param->kernel_params_buf32[26] = 0;
4846 device_param->kernel_params_buf32[27] = 0;
4847 device_param->kernel_params_buf32[28] = 0;
4848 device_param->kernel_params_buf32[29] = 0;
4849 device_param->kernel_params_buf32[30] = 0;
4850 device_param->kernel_params_buf32[31] = 0;
4851
4852 data.dictfile = dictfile_old;
4853
4854 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4855 }
4856
4857 // hlfmt hashcat
4858
4859 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4860 {
4861 if (data.username == 0)
4862 {
4863 *hashbuf_pos = line_buf;
4864 *hashbuf_len = line_len;
4865 }
4866 else
4867 {
4868 char *pos = line_buf;
4869 int len = line_len;
4870
4871 for (int i = 0; i < line_len; i++, pos++, len--)
4872 {
4873 if (line_buf[i] == data.separator)
4874 {
4875 pos++;
4876
4877 len--;
4878
4879 break;
4880 }
4881 }
4882
4883 *hashbuf_pos = pos;
4884 *hashbuf_len = len;
4885 }
4886 }
4887
4888 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4889 {
4890 char *pos = NULL;
4891 int len = 0;
4892
4893 int sep_cnt = 0;
4894
4895 for (int i = 0; i < line_len; i++)
4896 {
4897 if (line_buf[i] == data.separator)
4898 {
4899 sep_cnt++;
4900
4901 continue;
4902 }
4903
4904 if (sep_cnt == 0)
4905 {
4906 if (pos == NULL) pos = line_buf + i;
4907
4908 len++;
4909 }
4910 }
4911
4912 *userbuf_pos = pos;
4913 *userbuf_len = len;
4914 }
4915
4916 // hlfmt pwdump
4917
4918 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
4919 {
4920 int sep_cnt = 0;
4921
4922 int sep2_len = 0;
4923 int sep3_len = 0;
4924
4925 for (int i = 0; i < line_len; i++)
4926 {
4927 if (line_buf[i] == ':')
4928 {
4929 sep_cnt++;
4930
4931 continue;
4932 }
4933
4934 if (sep_cnt == 2) sep2_len++;
4935 if (sep_cnt == 3) sep3_len++;
4936 }
4937
4938 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4939
4940 return 0;
4941 }
4942
4943 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4944 {
4945 char *pos = NULL;
4946 int len = 0;
4947
4948 int sep_cnt = 0;
4949
4950 for (int i = 0; i < line_len; i++)
4951 {
4952 if (line_buf[i] == ':')
4953 {
4954 sep_cnt++;
4955
4956 continue;
4957 }
4958
4959 if (data.hash_mode == 1000)
4960 {
4961 if (sep_cnt == 3)
4962 {
4963 if (pos == NULL) pos = line_buf + i;
4964
4965 len++;
4966 }
4967 }
4968 else if (data.hash_mode == 3000)
4969 {
4970 if (sep_cnt == 2)
4971 {
4972 if (pos == NULL) pos = line_buf + i;
4973
4974 len++;
4975 }
4976 }
4977 }
4978
4979 *hashbuf_pos = pos;
4980 *hashbuf_len = len;
4981 }
4982
4983 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4984 {
4985 char *pos = NULL;
4986 int len = 0;
4987
4988 int sep_cnt = 0;
4989
4990 for (int i = 0; i < line_len; i++)
4991 {
4992 if (line_buf[i] == ':')
4993 {
4994 sep_cnt++;
4995
4996 continue;
4997 }
4998
4999 if (sep_cnt == 0)
5000 {
5001 if (pos == NULL) pos = line_buf + i;
5002
5003 len++;
5004 }
5005 }
5006
5007 *userbuf_pos = pos;
5008 *userbuf_len = len;
5009 }
5010
5011 // hlfmt passwd
5012
5013 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5014 {
5015 int sep_cnt = 0;
5016
5017 char sep5_first = 0;
5018 char sep6_first = 0;
5019
5020 for (int i = 0; i < line_len; i++)
5021 {
5022 if (line_buf[i] == ':')
5023 {
5024 sep_cnt++;
5025
5026 continue;
5027 }
5028
5029 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5030 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5031 }
5032
5033 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5034
5035 return 0;
5036 }
5037
5038 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5039 {
5040 char *pos = NULL;
5041 int len = 0;
5042
5043 int sep_cnt = 0;
5044
5045 for (int i = 0; i < line_len; i++)
5046 {
5047 if (line_buf[i] == ':')
5048 {
5049 sep_cnt++;
5050
5051 continue;
5052 }
5053
5054 if (sep_cnt == 1)
5055 {
5056 if (pos == NULL) pos = line_buf + i;
5057
5058 len++;
5059 }
5060 }
5061
5062 *hashbuf_pos = pos;
5063 *hashbuf_len = len;
5064 }
5065
5066 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5067 {
5068 char *pos = NULL;
5069 int len = 0;
5070
5071 int sep_cnt = 0;
5072
5073 for (int i = 0; i < line_len; i++)
5074 {
5075 if (line_buf[i] == ':')
5076 {
5077 sep_cnt++;
5078
5079 continue;
5080 }
5081
5082 if (sep_cnt == 0)
5083 {
5084 if (pos == NULL) pos = line_buf + i;
5085
5086 len++;
5087 }
5088 }
5089
5090 *userbuf_pos = pos;
5091 *userbuf_len = len;
5092 }
5093
5094 // hlfmt shadow
5095
5096 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5097 {
5098 int sep_cnt = 0;
5099
5100 for (int i = 0; i < line_len; i++)
5101 {
5102 if (line_buf[i] == ':') sep_cnt++;
5103 }
5104
5105 if (sep_cnt == 8) return 1;
5106
5107 return 0;
5108 }
5109
5110 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5111 {
5112 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5113 }
5114
5115 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5116 {
5117 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5118 }
5119
5120 // hlfmt main
5121
5122 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5123 {
5124 switch (hashfile_format)
5125 {
5126 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5127 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5128 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5129 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5130 }
5131 }
5132
5133 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5134 {
5135 switch (hashfile_format)
5136 {
5137 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5138 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5139 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5140 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5141 }
5142 }
5143
5144 char *strhlfmt (const uint hashfile_format)
5145 {
5146 switch (hashfile_format)
5147 {
5148 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5149 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5150 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5151 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5152 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5153 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5154 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5155 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5156 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5157 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5158 }
5159
5160 return ((char *) "Unknown");
5161 }
5162
5163 static uint hlfmt_detect (FILE *fp, uint max_check)
5164 {
5165 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5166
5167 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5168 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5169
5170 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5171
5172 uint num_check = 0;
5173
5174 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5175
5176 while (!feof (fp))
5177 {
5178 int line_len = fgetl (fp, line_buf);
5179
5180 if (line_len == 0) continue;
5181
5182 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5183 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5184 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5185
5186 if (num_check == max_check) break;
5187
5188 num_check++;
5189 }
5190
5191 myfree (line_buf);
5192
5193 uint hashlist_format = HLFMT_HASHCAT;
5194
5195 for (int i = 1; i < HLFMTS_CNT; i++)
5196 {
5197 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5198
5199 hashlist_format = i;
5200 }
5201
5202 free (formats_cnt);
5203
5204 return hashlist_format;
5205 }
5206
5207 /**
5208 * some further helper function
5209 */
5210
5211 // wrapper around mymalloc for ADL
5212
5213 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5214 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5215 {
5216 return mymalloc (iSize);
5217 }
5218 #endif
5219
5220 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)
5221 {
5222 u64 collisions = 0;
5223
5224 const uint dgst_pos0 = data.dgst_pos0;
5225 const uint dgst_pos1 = data.dgst_pos1;
5226 const uint dgst_pos2 = data.dgst_pos2;
5227 const uint dgst_pos3 = data.dgst_pos3;
5228
5229 memset (bitmap_a, 0, bitmap_size);
5230 memset (bitmap_b, 0, bitmap_size);
5231 memset (bitmap_c, 0, bitmap_size);
5232 memset (bitmap_d, 0, bitmap_size);
5233
5234 for (uint i = 0; i < digests_cnt; i++)
5235 {
5236 uint *digest_ptr = (uint *) digests_buf_ptr;
5237
5238 digests_buf_ptr += dgst_size;
5239
5240 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5241 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5242 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5243 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5244
5245 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5246 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5247 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5248 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5249
5250 if (bitmap_a[idx0] & val0) collisions++;
5251 if (bitmap_b[idx1] & val1) collisions++;
5252 if (bitmap_c[idx2] & val2) collisions++;
5253 if (bitmap_d[idx3] & val3) collisions++;
5254
5255 bitmap_a[idx0] |= val0;
5256 bitmap_b[idx1] |= val1;
5257 bitmap_c[idx2] |= val2;
5258 bitmap_d[idx3] |= val3;
5259
5260 if (collisions >= collisions_max) return 0x7fffffff;
5261 }
5262
5263 return collisions;
5264 }
5265
5266 /**
5267 * main
5268 */
5269
5270 int main (int argc, char **argv)
5271 {
5272 /**
5273 * To help users a bit
5274 */
5275
5276 char *compute = getenv ("COMPUTE");
5277
5278 if (compute)
5279 {
5280 static char display[100];
5281
5282 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5283
5284 putenv (display);
5285 }
5286 else
5287 {
5288 if (getenv ("DISPLAY") == NULL)
5289 putenv ((char *) "DISPLAY=:0");
5290 }
5291
5292 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5293 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5294
5295 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5296 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5297
5298 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5299 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5300
5301 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5302 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5303
5304 /**
5305 * Real init
5306 */
5307
5308 memset (&data, 0, sizeof (hc_global_data_t));
5309
5310 time_t proc_start;
5311
5312 time (&proc_start);
5313
5314 data.proc_start = proc_start;
5315
5316 int myargc = argc;
5317 char **myargv = argv;
5318
5319 hc_thread_mutex_init (mux_dispatcher);
5320 hc_thread_mutex_init (mux_counter);
5321 hc_thread_mutex_init (mux_display);
5322 hc_thread_mutex_init (mux_adl);
5323
5324 /**
5325 * commandline parameters
5326 */
5327
5328 uint usage = USAGE;
5329 uint version = VERSION;
5330 uint quiet = QUIET;
5331 uint benchmark = BENCHMARK;
5332 uint benchmark_repeats = BENCHMARK_REPEATS;
5333 uint show = SHOW;
5334 uint left = LEFT;
5335 uint username = USERNAME;
5336 uint remove = REMOVE;
5337 uint remove_timer = REMOVE_TIMER;
5338 u64 skip = SKIP;
5339 u64 limit = LIMIT;
5340 uint keyspace = KEYSPACE;
5341 uint potfile_disable = POTFILE_DISABLE;
5342 uint debug_mode = DEBUG_MODE;
5343 char *debug_file = NULL;
5344 char *induction_dir = NULL;
5345 char *outfile_check_dir = NULL;
5346 uint force = FORCE;
5347 uint runtime = RUNTIME;
5348 uint hash_mode = HASH_MODE;
5349 uint attack_mode = ATTACK_MODE;
5350 uint markov_disable = MARKOV_DISABLE;
5351 uint markov_classic = MARKOV_CLASSIC;
5352 uint markov_threshold = MARKOV_THRESHOLD;
5353 char *markov_hcstat = NULL;
5354 char *outfile = NULL;
5355 uint outfile_format = OUTFILE_FORMAT;
5356 uint outfile_autohex = OUTFILE_AUTOHEX;
5357 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5358 uint restore = RESTORE;
5359 uint restore_timer = RESTORE_TIMER;
5360 uint restore_disable = RESTORE_DISABLE;
5361 uint status = STATUS;
5362 uint status_timer = STATUS_TIMER;
5363 uint status_automat = STATUS_AUTOMAT;
5364 uint loopback = LOOPBACK;
5365 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5366 char *session = NULL;
5367 uint hex_charset = HEX_CHARSET;
5368 uint hex_salt = HEX_SALT;
5369 uint hex_wordlist = HEX_WORDLIST;
5370 uint rp_gen = RP_GEN;
5371 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5372 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5373 uint rp_gen_seed = RP_GEN_SEED;
5374 char *rule_buf_l = (char *) RULE_BUF_L;
5375 char *rule_buf_r = (char *) RULE_BUF_R;
5376 uint increment = INCREMENT;
5377 uint increment_min = INCREMENT_MIN;
5378 uint increment_max = INCREMENT_MAX;
5379 char *cpu_affinity = NULL;
5380 OCL_PTR *ocl = NULL;
5381 char *opencl_devices = NULL;
5382 char *opencl_platforms = NULL;
5383 char *opencl_device_types = NULL;
5384 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5385 char *truecrypt_keyfiles = NULL;
5386 uint workload_profile = WORKLOAD_PROFILE;
5387 uint kernel_accel = KERNEL_ACCEL;
5388 uint kernel_loops = KERNEL_LOOPS;
5389 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5390 #ifdef HAVE_HWMON
5391 uint gpu_temp_abort = GPU_TEMP_ABORT;
5392 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5393 #ifdef HAVE_ADL
5394 uint powertune_enable = POWERTUNE_ENABLE;
5395 #endif
5396 #endif
5397 uint logfile_disable = LOGFILE_DISABLE;
5398 uint segment_size = SEGMENT_SIZE;
5399 uint scrypt_tmto = SCRYPT_TMTO;
5400 char separator = SEPARATOR;
5401 uint bitmap_min = BITMAP_MIN;
5402 uint bitmap_max = BITMAP_MAX;
5403 char *custom_charset_1 = NULL;
5404 char *custom_charset_2 = NULL;
5405 char *custom_charset_3 = NULL;
5406 char *custom_charset_4 = NULL;
5407
5408 #define IDX_HELP 'h'
5409 #define IDX_VERSION 'V'
5410 #define IDX_VERSION_LOWER 'v'
5411 #define IDX_QUIET 0xff02
5412 #define IDX_SHOW 0xff03
5413 #define IDX_LEFT 0xff04
5414 #define IDX_REMOVE 0xff05
5415 #define IDX_REMOVE_TIMER 0xff37
5416 #define IDX_SKIP 's'
5417 #define IDX_LIMIT 'l'
5418 #define IDX_KEYSPACE 0xff35
5419 #define IDX_POTFILE_DISABLE 0xff06
5420 #define IDX_DEBUG_MODE 0xff43
5421 #define IDX_DEBUG_FILE 0xff44
5422 #define IDX_INDUCTION_DIR 0xff46
5423 #define IDX_OUTFILE_CHECK_DIR 0xff47
5424 #define IDX_USERNAME 0xff07
5425 #define IDX_FORCE 0xff08
5426 #define IDX_RUNTIME 0xff09
5427 #define IDX_BENCHMARK 'b'
5428 #define IDX_BENCHMARK_REPEATS 0xff78
5429 #define IDX_HASH_MODE 'm'
5430 #define IDX_ATTACK_MODE 'a'
5431 #define IDX_RP_FILE 'r'
5432 #define IDX_RP_GEN 'g'
5433 #define IDX_RP_GEN_FUNC_MIN 0xff10
5434 #define IDX_RP_GEN_FUNC_MAX 0xff11
5435 #define IDX_RP_GEN_SEED 0xff34
5436 #define IDX_RULE_BUF_L 'j'
5437 #define IDX_RULE_BUF_R 'k'
5438 #define IDX_INCREMENT 'i'
5439 #define IDX_INCREMENT_MIN 0xff12
5440 #define IDX_INCREMENT_MAX 0xff13
5441 #define IDX_OUTFILE 'o'
5442 #define IDX_OUTFILE_FORMAT 0xff14
5443 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5444 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5445 #define IDX_RESTORE 0xff15
5446 #define IDX_RESTORE_DISABLE 0xff27
5447 #define IDX_STATUS 0xff17
5448 #define IDX_STATUS_TIMER 0xff18
5449 #define IDX_STATUS_AUTOMAT 0xff50
5450 #define IDX_LOOPBACK 0xff38
5451 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5452 #define IDX_SESSION 0xff19
5453 #define IDX_HEX_CHARSET 0xff20
5454 #define IDX_HEX_SALT 0xff21
5455 #define IDX_HEX_WORDLIST 0xff40
5456 #define IDX_MARKOV_DISABLE 0xff22
5457 #define IDX_MARKOV_CLASSIC 0xff23
5458 #define IDX_MARKOV_THRESHOLD 't'
5459 #define IDX_MARKOV_HCSTAT 0xff24
5460 #define IDX_CPU_AFFINITY 0xff25
5461 #define IDX_OPENCL_DEVICES 'd'
5462 #define IDX_OPENCL_PLATFORMS 0xff72
5463 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5464 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5465 #define IDX_WORKLOAD_PROFILE 'w'
5466 #define IDX_KERNEL_ACCEL 'n'
5467 #define IDX_KERNEL_LOOPS 'u'
5468 #define IDX_GPU_TEMP_DISABLE 0xff29
5469 #define IDX_GPU_TEMP_ABORT 0xff30
5470 #define IDX_GPU_TEMP_RETAIN 0xff31
5471 #define IDX_POWERTUNE_ENABLE 0xff41
5472 #define IDX_LOGFILE_DISABLE 0xff51
5473 #define IDX_TRUECRYPT_KEYFILES 0xff52
5474 #define IDX_SCRYPT_TMTO 0xff61
5475 #define IDX_SEGMENT_SIZE 'c'
5476 #define IDX_SEPARATOR 'p'
5477 #define IDX_BITMAP_MIN 0xff70
5478 #define IDX_BITMAP_MAX 0xff71
5479 #define IDX_CUSTOM_CHARSET_1 '1'
5480 #define IDX_CUSTOM_CHARSET_2 '2'
5481 #define IDX_CUSTOM_CHARSET_3 '3'
5482 #define IDX_CUSTOM_CHARSET_4 '4'
5483
5484 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5485
5486 struct option long_options[] =
5487 {
5488 {"help", no_argument, 0, IDX_HELP},
5489 {"version", no_argument, 0, IDX_VERSION},
5490 {"quiet", no_argument, 0, IDX_QUIET},
5491 {"show", no_argument, 0, IDX_SHOW},
5492 {"left", no_argument, 0, IDX_LEFT},
5493 {"username", no_argument, 0, IDX_USERNAME},
5494 {"remove", no_argument, 0, IDX_REMOVE},
5495 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5496 {"skip", required_argument, 0, IDX_SKIP},
5497 {"limit", required_argument, 0, IDX_LIMIT},
5498 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5499 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5500 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5501 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5502 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5503 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5504 {"force", no_argument, 0, IDX_FORCE},
5505 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5506 {"benchmark-repeats", required_argument, 0, IDX_BENCHMARK_REPEATS},
5507 {"restore", no_argument, 0, IDX_RESTORE},
5508 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5509 {"status", no_argument, 0, IDX_STATUS},
5510 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5511 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5512 {"loopback", no_argument, 0, IDX_LOOPBACK},
5513 {"weak-hash-threshold",
5514 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5515 {"session", required_argument, 0, IDX_SESSION},
5516 {"runtime", required_argument, 0, IDX_RUNTIME},
5517 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5518 {"generate-rules-func-min",
5519 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5520 {"generate-rules-func-max",
5521 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5522 {"generate-rules-seed",
5523 required_argument, 0, IDX_RP_GEN_SEED},
5524 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5525 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5526 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5527 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5528 {"rules-file", required_argument, 0, IDX_RP_FILE},
5529 {"outfile", required_argument, 0, IDX_OUTFILE},
5530 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5531 {"outfile-autohex-disable",
5532 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5533 {"outfile-check-timer",
5534 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5535 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5536 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5537 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5538 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5539 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5540 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5541 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5542 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5543 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5544 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5545 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5546 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5547 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5548 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5549 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5550 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5551 #ifdef HAVE_HWMON
5552 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5553 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5554 #ifdef HAVE_ADL
5555 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5556 #endif
5557 #endif // HAVE_HWMON
5558 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5559 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5560 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5561 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5562 // deprecated
5563 {"seperator", required_argument, 0, IDX_SEPARATOR},
5564 {"separator", required_argument, 0, IDX_SEPARATOR},
5565 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5566 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5567 {"increment", no_argument, 0, IDX_INCREMENT},
5568 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5569 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5570 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5571 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5572 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5573 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5574
5575 {0, 0, 0, 0}
5576 };
5577
5578 uint rp_files_cnt = 0;
5579
5580 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5581
5582 int option_index = 0;
5583 int c = -1;
5584
5585 optind = 1;
5586 optopt = 0;
5587
5588 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5589 {
5590 switch (c)
5591 {
5592 case IDX_HELP: usage = 1; break;
5593 case IDX_VERSION:
5594 case IDX_VERSION_LOWER: version = 1; break;
5595 case IDX_RESTORE: restore = 1; break;
5596 case IDX_SESSION: session = optarg; break;
5597 case IDX_SHOW: show = 1; break;
5598 case IDX_LEFT: left = 1; break;
5599 case '?': return (-1);
5600 }
5601 }
5602
5603 if (optopt != 0)
5604 {
5605 log_error ("ERROR: Invalid argument specified");
5606
5607 return (-1);
5608 }
5609
5610 /**
5611 * exit functions
5612 */
5613
5614 if (version)
5615 {
5616 log_info ("%s (%s)", VERSION_TAG, VERSION_SUM);
5617
5618 return (0);
5619 }
5620
5621 if (usage)
5622 {
5623 usage_big_print (PROGNAME);
5624
5625 return (0);
5626 }
5627
5628 /**
5629 * session needs to be set, always!
5630 */
5631
5632 if (session == NULL) session = (char *) PROGNAME;
5633
5634 /**
5635 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5636 */
5637
5638 char *exec_path = get_exec_path ();
5639
5640 #ifdef LINUX
5641
5642 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5643 char *resolved_exec_path = realpath (exec_path, NULL);
5644
5645 char *install_dir = get_install_dir (resolved_exec_path);
5646 char *profile_dir = NULL;
5647 char *session_dir = NULL;
5648 char *shared_dir = NULL;
5649
5650 if (strcmp (install_dir, resolved_install_folder) == 0)
5651 {
5652 struct passwd *pw = getpwuid (getuid ());
5653
5654 const char *homedir = pw->pw_dir;
5655
5656 profile_dir = get_profile_dir (homedir);
5657 session_dir = get_session_dir (profile_dir);
5658 shared_dir = strdup (SHARED_FOLDER);
5659
5660 mkdir (profile_dir, 0700);
5661 mkdir (session_dir, 0700);
5662 }
5663 else
5664 {
5665 profile_dir = install_dir;
5666 session_dir = install_dir;
5667 shared_dir = install_dir;
5668 }
5669
5670 myfree (resolved_install_folder);
5671 myfree (resolved_exec_path);
5672
5673 #else
5674
5675 char *install_dir = get_install_dir (exec_path);
5676 char *profile_dir = install_dir;
5677 char *session_dir = install_dir;
5678 char *shared_dir = install_dir;
5679
5680 #endif
5681
5682 data.install_dir = install_dir;
5683 data.profile_dir = profile_dir;
5684 data.session_dir = session_dir;
5685 data.shared_dir = shared_dir;
5686
5687 myfree (exec_path);
5688
5689 /**
5690 * kernel cache, we need to make sure folder exist
5691 */
5692
5693 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5694
5695 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5696
5697 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5698
5699 mkdir (kernels_folder, 0700);
5700
5701 myfree (kernels_folder);
5702
5703 /**
5704 * session
5705 */
5706
5707 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5708
5709 data.session = session;
5710
5711 char *eff_restore_file = (char *) mymalloc (session_size);
5712 char *new_restore_file = (char *) mymalloc (session_size);
5713
5714 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5715 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5716
5717 data.eff_restore_file = eff_restore_file;
5718 data.new_restore_file = new_restore_file;
5719
5720 if (((show == 1) || (left == 1)) && (restore == 1))
5721 {
5722 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5723 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5724
5725 return (-1);
5726 }
5727
5728 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5729 if ((show == 1) || (left == 1))
5730 {
5731 restore_disable = 1;
5732
5733 restore = 0;
5734 }
5735
5736 data.restore_disable = restore_disable;
5737
5738 restore_data_t *rd = init_restore (argc, argv);
5739
5740 data.rd = rd;
5741
5742 /**
5743 * restore file
5744 */
5745
5746 if (restore == 1)
5747 {
5748 read_restore (eff_restore_file, rd);
5749
5750 if (rd->version_bin < RESTORE_MIN)
5751 {
5752 log_error ("ERROR: Incompatible restore-file version");
5753
5754 return (-1);
5755 }
5756
5757 myargc = rd->argc;
5758 myargv = rd->argv;
5759
5760 #ifdef _POSIX
5761 rd->pid = getpid ();
5762 #elif _WIN
5763 rd->pid = GetCurrentProcessId ();
5764 #endif
5765 }
5766
5767 uint hash_mode_chgd = 0;
5768 uint runtime_chgd = 0;
5769 uint kernel_loops_chgd = 0;
5770 uint kernel_accel_chgd = 0;
5771 uint attack_mode_chgd = 0;
5772 uint outfile_format_chgd = 0;
5773 uint rp_gen_seed_chgd = 0;
5774 uint remove_timer_chgd = 0;
5775 uint increment_min_chgd = 0;
5776 uint increment_max_chgd = 0;
5777 uint workload_profile_chgd = 0;
5778 uint opencl_vector_width_chgd = 0;
5779
5780 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5781 uint gpu_temp_retain_chgd = 0;
5782 uint gpu_temp_abort_chgd = 0;
5783 #endif
5784
5785 optind = 1;
5786 optopt = 0;
5787 option_index = 0;
5788
5789 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5790 {
5791 switch (c)
5792 {
5793 //case IDX_HELP: usage = 1; break;
5794 //case IDX_VERSION: version = 1; break;
5795 //case IDX_RESTORE: restore = 1; break;
5796 case IDX_QUIET: quiet = 1; break;
5797 //case IDX_SHOW: show = 1; break;
5798 case IDX_SHOW: break;
5799 //case IDX_LEFT: left = 1; break;
5800 case IDX_LEFT: break;
5801 case IDX_USERNAME: username = 1; break;
5802 case IDX_REMOVE: remove = 1; break;
5803 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5804 remove_timer_chgd = 1; break;
5805 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5806 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5807 case IDX_DEBUG_FILE: debug_file = optarg; break;
5808 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5809 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5810 case IDX_FORCE: force = 1; break;
5811 case IDX_SKIP: skip = atoll (optarg); break;
5812 case IDX_LIMIT: limit = atoll (optarg); break;
5813 case IDX_KEYSPACE: keyspace = 1; break;
5814 case IDX_BENCHMARK: benchmark = 1; break;
5815 case IDX_BENCHMARK_REPEATS: benchmark_repeats = atoi (optarg); break;
5816 case IDX_RESTORE: break;
5817 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5818 case IDX_STATUS: status = 1; break;
5819 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5820 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5821 case IDX_LOOPBACK: loopback = 1; break;
5822 case IDX_WEAK_HASH_THRESHOLD:
5823 weak_hash_threshold = atoi (optarg); break;
5824 //case IDX_SESSION: session = optarg; break;
5825 case IDX_SESSION: break;
5826 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5827 hash_mode_chgd = 1; break;
5828 case IDX_RUNTIME: runtime = atoi (optarg);
5829 runtime_chgd = 1; break;
5830 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5831 attack_mode_chgd = 1; break;
5832 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5833 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5834 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5835 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5836 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5837 rp_gen_seed_chgd = 1; break;
5838 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5839 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5840 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5841 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5842 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5843 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5844 case IDX_OUTFILE: outfile = optarg; break;
5845 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5846 outfile_format_chgd = 1; break;
5847 case IDX_OUTFILE_AUTOHEX_DISABLE:
5848 outfile_autohex = 0; break;
5849 case IDX_OUTFILE_CHECK_TIMER:
5850 outfile_check_timer = atoi (optarg); break;
5851 case IDX_HEX_CHARSET: hex_charset = 1; break;
5852 case IDX_HEX_SALT: hex_salt = 1; break;
5853 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5854 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5855 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5856 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5857 case IDX_OPENCL_DEVICE_TYPES:
5858 opencl_device_types = optarg; break;
5859 case IDX_OPENCL_VECTOR_WIDTH:
5860 opencl_vector_width = atoi (optarg);
5861 opencl_vector_width_chgd = 1; break;
5862 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
5863 workload_profile_chgd = 1; break;
5864 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5865 kernel_accel_chgd = 1; break;
5866 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5867 kernel_loops_chgd = 1; break;
5868 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5869 #ifdef HAVE_HWMON
5870 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5871 #ifdef HAVE_ADL
5872 gpu_temp_abort_chgd = 1;
5873 #endif
5874 break;
5875 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5876 #ifdef HAVE_ADL
5877 gpu_temp_retain_chgd = 1;
5878 #endif
5879 break;
5880 #ifdef HAVE_ADL
5881 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5882 #endif
5883 #endif // HAVE_HWMON
5884 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5885 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5886 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5887 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5888 case IDX_SEPARATOR: separator = optarg[0]; break;
5889 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5890 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5891 case IDX_INCREMENT: increment = 1; break;
5892 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5893 increment_min_chgd = 1; break;
5894 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5895 increment_max_chgd = 1; break;
5896 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5897 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5898 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5899 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5900
5901 default:
5902 log_error ("ERROR: Invalid argument specified");
5903 return (-1);
5904 }
5905 }
5906
5907 if (optopt != 0)
5908 {
5909 log_error ("ERROR: Invalid argument specified");
5910
5911 return (-1);
5912 }
5913
5914 /**
5915 * Inform user things getting started,
5916 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5917 * - we do not need to check algorithm_pos
5918 */
5919
5920 if (quiet == 0)
5921 {
5922 if (benchmark == 1)
5923 {
5924 log_info ("%s %s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5925
5926 log_info ("");
5927 }
5928 else if (restore == 1)
5929 {
5930 log_info ("%s %s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5931
5932 log_info ("");
5933 }
5934 else
5935 {
5936 log_info ("%s %s (%s) starting...", PROGNAME, VERSION_TAG, VERSION_SUM);
5937
5938 log_info ("");
5939 }
5940 }
5941
5942 /**
5943 * sanity check
5944 */
5945
5946 if (attack_mode > 7)
5947 {
5948 log_error ("ERROR: Invalid attack-mode specified");
5949
5950 return (-1);
5951 }
5952
5953 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5954 {
5955 log_error ("ERROR: Invalid runtime specified");
5956
5957 return (-1);
5958 }
5959
5960 if (hash_mode_chgd && hash_mode > 13400) // just added to remove compiler warnings for hash_mode_chgd
5961 {
5962 log_error ("ERROR: Invalid hash-type specified");
5963
5964 return (-1);
5965 }
5966
5967 // renamed hash modes
5968
5969 if (hash_mode_chgd)
5970 {
5971 int n = -1;
5972
5973 switch (hash_mode)
5974 {
5975 case 123: n = 124;
5976 break;
5977 }
5978
5979 if (n >= 0)
5980 {
5981 log_error ("Old -m specified, use -m %d instead", n);
5982
5983 return (-1);
5984 }
5985 }
5986
5987 if (username == 1)
5988 {
5989 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
5990 {
5991 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5992
5993 return (-1);
5994 }
5995 }
5996
5997 if (outfile_format > 16)
5998 {
5999 log_error ("ERROR: Invalid outfile-format specified");
6000
6001 return (-1);
6002 }
6003
6004 if (left == 1)
6005 {
6006 if (outfile_format_chgd == 1)
6007 {
6008 if (outfile_format > 1)
6009 {
6010 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6011
6012 return (-1);
6013 }
6014 }
6015 else
6016 {
6017 outfile_format = OUTFILE_FMT_HASH;
6018 }
6019 }
6020
6021 if (show == 1)
6022 {
6023 if (outfile_format_chgd == 1)
6024 {
6025 if ((outfile_format > 7) && (outfile_format < 16))
6026 {
6027 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6028
6029 return (-1);
6030 }
6031 }
6032 }
6033
6034 if (increment_min < INCREMENT_MIN)
6035 {
6036 log_error ("ERROR: Invalid increment-min specified");
6037
6038 return (-1);
6039 }
6040
6041 if (increment_max > INCREMENT_MAX)
6042 {
6043 log_error ("ERROR: Invalid increment-max specified");
6044
6045 return (-1);
6046 }
6047
6048 if (increment_min > increment_max)
6049 {
6050 log_error ("ERROR: Invalid increment-min specified");
6051
6052 return (-1);
6053 }
6054
6055 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6056 {
6057 log_error ("ERROR: increment is not allowed in attack-mode 0");
6058
6059 return (-1);
6060 }
6061
6062 if ((increment == 0) && (increment_min_chgd == 1))
6063 {
6064 log_error ("ERROR: increment-min is only supported together with increment switch");
6065
6066 return (-1);
6067 }
6068
6069 if ((increment == 0) && (increment_max_chgd == 1))
6070 {
6071 log_error ("ERROR: increment-max is only supported together with increment switch");
6072
6073 return (-1);
6074 }
6075
6076 if (rp_files_cnt && rp_gen)
6077 {
6078 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6079
6080 return (-1);
6081 }
6082
6083 if (rp_files_cnt || rp_gen)
6084 {
6085 if (attack_mode != ATTACK_MODE_STRAIGHT)
6086 {
6087 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6088
6089 return (-1);
6090 }
6091 }
6092
6093 if (rp_gen_func_min > rp_gen_func_max)
6094 {
6095 log_error ("ERROR: Invalid rp-gen-func-min specified");
6096
6097 return (-1);
6098 }
6099
6100 if (kernel_accel_chgd == 1)
6101 {
6102 if (kernel_accel < 1)
6103 {
6104 log_error ("ERROR: Invalid kernel-accel specified");
6105
6106 return (-1);
6107 }
6108
6109 if (kernel_accel > 1024)
6110 {
6111 log_error ("ERROR: Invalid kernel-accel specified");
6112
6113 return (-1);
6114 }
6115 }
6116
6117 if (kernel_loops_chgd == 1)
6118 {
6119 if (kernel_loops < 1)
6120 {
6121 log_error ("ERROR: Invalid kernel-loops specified");
6122
6123 return (-1);
6124 }
6125
6126 if (kernel_loops > 1024)
6127 {
6128 log_error ("ERROR: Invalid kernel-loops specified");
6129
6130 return (-1);
6131 }
6132 }
6133
6134 if ((workload_profile < 1) || (workload_profile > 3))
6135 {
6136 log_error ("ERROR: workload-profile %i not available", workload_profile);
6137
6138 return (-1);
6139 }
6140
6141 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6142 {
6143 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6144
6145 return (-1);
6146 }
6147
6148 if (show == 1 || left == 1)
6149 {
6150 attack_mode = ATTACK_MODE_NONE;
6151
6152 if (remove == 1)
6153 {
6154 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6155
6156 return (-1);
6157 }
6158
6159 if (potfile_disable == 1)
6160 {
6161 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6162
6163 return (-1);
6164 }
6165 }
6166
6167 uint attack_kern = ATTACK_KERN_NONE;
6168
6169 switch (attack_mode)
6170 {
6171 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6172 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6173 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6174 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6175 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6176 }
6177
6178 if (benchmark == 0)
6179 {
6180 if (keyspace == 1)
6181 {
6182 int num_additional_params = 1;
6183
6184 if (attack_kern == ATTACK_KERN_COMBI)
6185 {
6186 num_additional_params = 2;
6187 }
6188
6189 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6190
6191 if (keyspace_wordlist_specified == 0) optind--;
6192 }
6193
6194 if (attack_kern == ATTACK_KERN_NONE)
6195 {
6196 if ((optind + 1) != myargc)
6197 {
6198 usage_mini_print (myargv[0]);
6199
6200 return (-1);
6201 }
6202 }
6203 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6204 {
6205 if ((optind + 1) > myargc)
6206 {
6207 usage_mini_print (myargv[0]);
6208
6209 return (-1);
6210 }
6211 }
6212 else if (attack_kern == ATTACK_KERN_COMBI)
6213 {
6214 if ((optind + 3) != myargc)
6215 {
6216 usage_mini_print (myargv[0]);
6217
6218 return (-1);
6219 }
6220 }
6221 else if (attack_kern == ATTACK_KERN_BF)
6222 {
6223 if ((optind + 1) > myargc)
6224 {
6225 usage_mini_print (myargv[0]);
6226
6227 return (-1);
6228 }
6229 }
6230 else
6231 {
6232 usage_mini_print (myargv[0]);
6233
6234 return (-1);
6235 }
6236 }
6237 else
6238 {
6239 if (myargv[optind] != 0)
6240 {
6241 log_error ("ERROR: Invalid argument for benchmark mode specified");
6242
6243 return (-1);
6244 }
6245
6246 if (attack_mode_chgd == 1)
6247 {
6248 if (attack_mode != ATTACK_MODE_BF)
6249 {
6250 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6251
6252 return (-1);
6253 }
6254 }
6255 }
6256
6257 if (skip != 0 && limit != 0)
6258 {
6259 limit += skip;
6260 }
6261
6262 if (keyspace == 1)
6263 {
6264 if (show == 1)
6265 {
6266 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6267
6268 return (-1);
6269 }
6270 else if (left == 1)
6271 {
6272 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6273
6274 return (-1);
6275 }
6276
6277 potfile_disable = 1;
6278
6279 restore_disable = 1;
6280
6281 restore = 0;
6282
6283 weak_hash_threshold = 0;
6284
6285 quiet = 1;
6286 }
6287
6288 if (remove_timer_chgd == 1)
6289 {
6290 if (remove == 0)
6291 {
6292 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6293
6294 return (-1);
6295 }
6296
6297 if (remove_timer < 1)
6298 {
6299 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6300
6301 return (-1);
6302 }
6303 }
6304
6305 if (loopback == 1)
6306 {
6307 if (attack_mode == ATTACK_MODE_BF)
6308 {
6309 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
6310
6311 return (-1);
6312 }
6313 else if (attack_mode == ATTACK_MODE_STRAIGHT)
6314 {
6315 if ((rp_files_cnt == 0) && (rp_gen == 0))
6316 {
6317 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6318
6319 return (-1);
6320 }
6321 }
6322 }
6323
6324 if (debug_mode > 0)
6325 {
6326 if (attack_mode != ATTACK_MODE_STRAIGHT)
6327 {
6328 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6329
6330 return (-1);
6331 }
6332
6333 if ((rp_files_cnt == 0) && (rp_gen == 0))
6334 {
6335 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6336
6337 return (-1);
6338 }
6339 }
6340
6341 if (debug_mode > 4)
6342 {
6343 log_error ("ERROR: Invalid debug-mode specified");
6344
6345 return (-1);
6346 }
6347
6348 if (debug_file != NULL)
6349 {
6350 if (debug_mode < 1)
6351 {
6352 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6353
6354 return (-1);
6355 }
6356 }
6357
6358 if (induction_dir != NULL)
6359 {
6360 if (attack_mode == ATTACK_MODE_BF)
6361 {
6362 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6363
6364 return (-1);
6365 }
6366 }
6367
6368 if (attack_mode != ATTACK_MODE_STRAIGHT)
6369 {
6370 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6371 {
6372 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6373
6374 return (-1);
6375 }
6376
6377 weak_hash_threshold = 0;
6378 }
6379
6380 /**
6381 * induction directory
6382 */
6383
6384 char *induction_directory = NULL;
6385
6386 if (attack_mode != ATTACK_MODE_BF)
6387 {
6388 if (induction_dir == NULL)
6389 {
6390 induction_directory = (char *) mymalloc (session_size);
6391
6392 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6393
6394 // create induction folder if it does not already exist
6395
6396 if (keyspace == 0)
6397 {
6398 if (rmdir (induction_directory) == -1)
6399 {
6400 if (errno == ENOENT)
6401 {
6402 // good, we can ignore
6403 }
6404 else if (errno == ENOTEMPTY)
6405 {
6406 char *induction_directory_mv = (char *) mymalloc (session_size);
6407
6408 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6409
6410 if (rename (induction_directory, induction_directory_mv) != 0)
6411 {
6412 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6413
6414 return (-1);
6415 }
6416 }
6417 else
6418 {
6419 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6420
6421 return (-1);
6422 }
6423 }
6424
6425 if (mkdir (induction_directory, 0700) == -1)
6426 {
6427 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6428
6429 return (-1);
6430 }
6431 }
6432 }
6433 else
6434 {
6435 induction_directory = induction_dir;
6436 }
6437 }
6438
6439 data.induction_directory = induction_directory;
6440
6441 /**
6442 * loopback
6443 */
6444
6445 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6446
6447 char *loopback_file = (char *) mymalloc (loopback_size);
6448
6449 /**
6450 * tuning db
6451 */
6452
6453 char tuning_db_file[256] = { 0 };
6454
6455 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6456
6457 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6458
6459 /**
6460 * outfile-check directory
6461 */
6462
6463 char *outfile_check_directory = NULL;
6464
6465 if (outfile_check_dir == NULL)
6466 {
6467 outfile_check_directory = (char *) mymalloc (session_size);
6468
6469 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6470 }
6471 else
6472 {
6473 outfile_check_directory = outfile_check_dir;
6474 }
6475
6476 data.outfile_check_directory = outfile_check_directory;
6477
6478 if (keyspace == 0)
6479 {
6480 struct stat outfile_check_stat;
6481
6482 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6483 {
6484 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6485
6486 if (is_dir == 0)
6487 {
6488 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6489
6490 return (-1);
6491 }
6492 }
6493 else if (outfile_check_dir == NULL)
6494 {
6495 if (mkdir (outfile_check_directory, 0700) == -1)
6496 {
6497 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6498
6499 return (-1);
6500 }
6501 }
6502 }
6503
6504 /**
6505 * special other stuff
6506 */
6507
6508 if (hash_mode == 9710)
6509 {
6510 outfile_format = 5;
6511 outfile_format_chgd = 1;
6512 }
6513
6514 if (hash_mode == 9810)
6515 {
6516 outfile_format = 5;
6517 outfile_format_chgd = 1;
6518 }
6519
6520 if (hash_mode == 10410)
6521 {
6522 outfile_format = 5;
6523 outfile_format_chgd = 1;
6524 }
6525
6526 /**
6527 * store stuff
6528 */
6529
6530 data.hash_mode = hash_mode;
6531 data.restore = restore;
6532 data.restore_timer = restore_timer;
6533 data.restore_disable = restore_disable;
6534 data.status = status;
6535 data.status_timer = status_timer;
6536 data.status_automat = status_automat;
6537 data.loopback = loopback;
6538 data.runtime = runtime;
6539 data.remove = remove;
6540 data.remove_timer = remove_timer;
6541 data.debug_mode = debug_mode;
6542 data.debug_file = debug_file;
6543 data.username = username;
6544 data.quiet = quiet;
6545 data.outfile = outfile;
6546 data.outfile_format = outfile_format;
6547 data.outfile_autohex = outfile_autohex;
6548 data.hex_charset = hex_charset;
6549 data.hex_salt = hex_salt;
6550 data.hex_wordlist = hex_wordlist;
6551 data.separator = separator;
6552 data.rp_files = rp_files;
6553 data.rp_files_cnt = rp_files_cnt;
6554 data.rp_gen = rp_gen;
6555 data.rp_gen_seed = rp_gen_seed;
6556 data.force = force;
6557 data.benchmark = benchmark;
6558 data.benchmark_repeats = benchmark_repeats;
6559 data.skip = skip;
6560 data.limit = limit;
6561 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6562 data.powertune_enable = powertune_enable;
6563 #endif
6564 data.logfile_disable = logfile_disable;
6565 data.truecrypt_keyfiles = truecrypt_keyfiles;
6566 data.scrypt_tmto = scrypt_tmto;
6567 data.workload_profile = workload_profile;
6568
6569 /**
6570 * cpu affinity
6571 */
6572
6573 if (cpu_affinity)
6574 {
6575 set_cpu_affinity (cpu_affinity);
6576 }
6577
6578 if (rp_gen_seed_chgd == 0)
6579 {
6580 srand (proc_start);
6581 }
6582 else
6583 {
6584 srand (rp_gen_seed);
6585 }
6586
6587 /**
6588 * logfile init
6589 */
6590
6591 if (logfile_disable == 0)
6592 {
6593 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6594
6595 char *logfile = (char *) mymalloc (logfile_size);
6596
6597 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6598
6599 data.logfile = logfile;
6600
6601 char *topid = logfile_generate_topid ();
6602
6603 data.topid = topid;
6604 }
6605
6606 // logfile_append() checks for logfile_disable internally to make it easier from here
6607
6608 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6609 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6610 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6611 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6612 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6613 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6614 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6615 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6616 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6617 #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));
6618
6619 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6620 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6621 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6622 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6623 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6624 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6625 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6626 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6627
6628 logfile_top_msg ("START");
6629
6630 logfile_top_uint (attack_mode);
6631 logfile_top_uint (attack_kern);
6632 logfile_top_uint (benchmark);
6633 logfile_top_uint (benchmark_repeats);
6634 logfile_top_uint (bitmap_min);
6635 logfile_top_uint (bitmap_max);
6636 logfile_top_uint (debug_mode);
6637 logfile_top_uint (force);
6638 logfile_top_uint (kernel_accel);
6639 logfile_top_uint (kernel_loops);
6640 logfile_top_uint (gpu_temp_disable);
6641 #ifdef HAVE_HWMON
6642 logfile_top_uint (gpu_temp_abort);
6643 logfile_top_uint (gpu_temp_retain);
6644 #endif
6645 logfile_top_uint (hash_mode);
6646 logfile_top_uint (hex_charset);
6647 logfile_top_uint (hex_salt);
6648 logfile_top_uint (hex_wordlist);
6649 logfile_top_uint (increment);
6650 logfile_top_uint (increment_max);
6651 logfile_top_uint (increment_min);
6652 logfile_top_uint (keyspace);
6653 logfile_top_uint (left);
6654 logfile_top_uint (logfile_disable);
6655 logfile_top_uint (loopback);
6656 logfile_top_uint (markov_classic);
6657 logfile_top_uint (markov_disable);
6658 logfile_top_uint (markov_threshold);
6659 logfile_top_uint (outfile_autohex);
6660 logfile_top_uint (outfile_check_timer);
6661 logfile_top_uint (outfile_format);
6662 logfile_top_uint (potfile_disable);
6663 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6664 logfile_top_uint (powertune_enable);
6665 #endif
6666 logfile_top_uint (scrypt_tmto);
6667 logfile_top_uint (quiet);
6668 logfile_top_uint (remove);
6669 logfile_top_uint (remove_timer);
6670 logfile_top_uint (restore);
6671 logfile_top_uint (restore_disable);
6672 logfile_top_uint (restore_timer);
6673 logfile_top_uint (rp_gen);
6674 logfile_top_uint (rp_gen_func_max);
6675 logfile_top_uint (rp_gen_func_min);
6676 logfile_top_uint (rp_gen_seed);
6677 logfile_top_uint (runtime);
6678 logfile_top_uint (segment_size);
6679 logfile_top_uint (show);
6680 logfile_top_uint (status);
6681 logfile_top_uint (status_automat);
6682 logfile_top_uint (status_timer);
6683 logfile_top_uint (usage);
6684 logfile_top_uint (username);
6685 logfile_top_uint (version);
6686 logfile_top_uint (weak_hash_threshold);
6687 logfile_top_uint (workload_profile);
6688 logfile_top_uint64 (limit);
6689 logfile_top_uint64 (skip);
6690 logfile_top_char (separator);
6691 logfile_top_string (cpu_affinity);
6692 logfile_top_string (custom_charset_1);
6693 logfile_top_string (custom_charset_2);
6694 logfile_top_string (custom_charset_3);
6695 logfile_top_string (custom_charset_4);
6696 logfile_top_string (debug_file);
6697 logfile_top_string (opencl_devices);
6698 logfile_top_string (opencl_platforms);
6699 logfile_top_string (opencl_device_types);
6700 logfile_top_uint (opencl_vector_width);
6701 logfile_top_string (induction_dir);
6702 logfile_top_string (markov_hcstat);
6703 logfile_top_string (outfile);
6704 logfile_top_string (outfile_check_dir);
6705 logfile_top_string (rule_buf_l);
6706 logfile_top_string (rule_buf_r);
6707 logfile_top_string (session);
6708 logfile_top_string (truecrypt_keyfiles);
6709
6710 /**
6711 * Init OpenCL library loader
6712 */
6713
6714 if (keyspace == 0)
6715 {
6716 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6717
6718 ocl_init (ocl);
6719
6720 data.ocl = ocl;
6721 }
6722
6723 /**
6724 * OpenCL platform selection
6725 */
6726
6727 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6728
6729 /**
6730 * OpenCL device selection
6731 */
6732
6733 u32 devices_filter = setup_devices_filter (opencl_devices);
6734
6735 /**
6736 * OpenCL device type selection
6737 */
6738
6739 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6740
6741 /**
6742 * benchmark
6743 */
6744
6745 if (benchmark == 1)
6746 {
6747 /**
6748 * disable useless stuff for benchmark
6749 */
6750
6751 status_timer = 0;
6752 restore_timer = 0;
6753 restore_disable = 1;
6754 potfile_disable = 1;
6755 weak_hash_threshold = 0;
6756 gpu_temp_disable = 1;
6757
6758 data.status_timer = status_timer;
6759 data.restore_timer = restore_timer;
6760 data.restore_disable = restore_disable;
6761
6762 /**
6763 * force attack mode to be bruteforce
6764 */
6765
6766 attack_mode = ATTACK_MODE_BF;
6767 attack_kern = ATTACK_KERN_BF;
6768
6769 if (workload_profile_chgd == 0)
6770 {
6771 workload_profile = 3;
6772
6773 data.workload_profile = workload_profile;
6774 }
6775 }
6776
6777 /**
6778 * config
6779 */
6780
6781 uint hash_type = 0;
6782 uint salt_type = 0;
6783 uint attack_exec = 0;
6784 uint opts_type = 0;
6785 uint kern_type = 0;
6786 uint dgst_size = 0;
6787 uint esalt_size = 0;
6788 uint opti_type = 0;
6789 uint dgst_pos0 = -1;
6790 uint dgst_pos1 = -1;
6791 uint dgst_pos2 = -1;
6792 uint dgst_pos3 = -1;
6793
6794 int (*parse_func) (char *, uint, hash_t *);
6795 int (*sort_by_digest) (const void *, const void *);
6796
6797 uint algorithm_pos = 0;
6798 uint algorithm_max = 1;
6799
6800 uint *algorithms = default_benchmark_algorithms;
6801
6802 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6803
6804 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6805 {
6806 /*
6807 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6808 * the following algos are skipped entirely
6809 */
6810
6811 if (algorithm_pos > 0)
6812 {
6813 local_free (rd);
6814
6815 rd = init_restore (argc, argv);
6816
6817 data.rd = rd;
6818 }
6819
6820 /**
6821 * update hash_mode in case of multihash benchmark
6822 */
6823
6824 if (benchmark == 1)
6825 {
6826 if (hash_mode_chgd == 0)
6827 {
6828 hash_mode = algorithms[algorithm_pos];
6829
6830 data.hash_mode = hash_mode;
6831 }
6832
6833 quiet = 1;
6834
6835 data.quiet = quiet;
6836 }
6837
6838 switch (hash_mode)
6839 {
6840 case 0: hash_type = HASH_TYPE_MD5;
6841 salt_type = SALT_TYPE_NONE;
6842 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6843 opts_type = OPTS_TYPE_PT_GENERATE_LE
6844 | OPTS_TYPE_PT_ADD80
6845 | OPTS_TYPE_PT_ADDBITS14;
6846 kern_type = KERN_TYPE_MD5;
6847 dgst_size = DGST_SIZE_4_4;
6848 parse_func = md5_parse_hash;
6849 sort_by_digest = sort_by_digest_4_4;
6850 opti_type = OPTI_TYPE_ZERO_BYTE
6851 | OPTI_TYPE_PRECOMPUTE_INIT
6852 | OPTI_TYPE_PRECOMPUTE_MERKLE
6853 | OPTI_TYPE_MEET_IN_MIDDLE
6854 | OPTI_TYPE_EARLY_SKIP
6855 | OPTI_TYPE_NOT_ITERATED
6856 | OPTI_TYPE_NOT_SALTED
6857 | OPTI_TYPE_RAW_HASH;
6858 dgst_pos0 = 0;
6859 dgst_pos1 = 3;
6860 dgst_pos2 = 2;
6861 dgst_pos3 = 1;
6862 break;
6863
6864 case 10: hash_type = HASH_TYPE_MD5;
6865 salt_type = SALT_TYPE_INTERN;
6866 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6867 opts_type = OPTS_TYPE_PT_GENERATE_LE
6868 | OPTS_TYPE_ST_ADD80
6869 | OPTS_TYPE_ST_ADDBITS14;
6870 kern_type = KERN_TYPE_MD5_PWSLT;
6871 dgst_size = DGST_SIZE_4_4;
6872 parse_func = md5s_parse_hash;
6873 sort_by_digest = sort_by_digest_4_4;
6874 opti_type = OPTI_TYPE_ZERO_BYTE
6875 | OPTI_TYPE_PRECOMPUTE_INIT
6876 | OPTI_TYPE_PRECOMPUTE_MERKLE
6877 | OPTI_TYPE_MEET_IN_MIDDLE
6878 | OPTI_TYPE_EARLY_SKIP
6879 | OPTI_TYPE_NOT_ITERATED
6880 | OPTI_TYPE_APPENDED_SALT
6881 | OPTI_TYPE_RAW_HASH;
6882 dgst_pos0 = 0;
6883 dgst_pos1 = 3;
6884 dgst_pos2 = 2;
6885 dgst_pos3 = 1;
6886 break;
6887
6888 case 11: hash_type = HASH_TYPE_MD5;
6889 salt_type = SALT_TYPE_INTERN;
6890 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6891 opts_type = OPTS_TYPE_PT_GENERATE_LE
6892 | OPTS_TYPE_ST_ADD80
6893 | OPTS_TYPE_ST_ADDBITS14;
6894 kern_type = KERN_TYPE_MD5_PWSLT;
6895 dgst_size = DGST_SIZE_4_4;
6896 parse_func = joomla_parse_hash;
6897 sort_by_digest = sort_by_digest_4_4;
6898 opti_type = OPTI_TYPE_ZERO_BYTE
6899 | OPTI_TYPE_PRECOMPUTE_INIT
6900 | OPTI_TYPE_PRECOMPUTE_MERKLE
6901 | OPTI_TYPE_MEET_IN_MIDDLE
6902 | OPTI_TYPE_EARLY_SKIP
6903 | OPTI_TYPE_NOT_ITERATED
6904 | OPTI_TYPE_APPENDED_SALT
6905 | OPTI_TYPE_RAW_HASH;
6906 dgst_pos0 = 0;
6907 dgst_pos1 = 3;
6908 dgst_pos2 = 2;
6909 dgst_pos3 = 1;
6910 break;
6911
6912 case 12: hash_type = HASH_TYPE_MD5;
6913 salt_type = SALT_TYPE_INTERN;
6914 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6915 opts_type = OPTS_TYPE_PT_GENERATE_LE
6916 | OPTS_TYPE_ST_ADD80
6917 | OPTS_TYPE_ST_ADDBITS14;
6918 kern_type = KERN_TYPE_MD5_PWSLT;
6919 dgst_size = DGST_SIZE_4_4;
6920 parse_func = postgresql_parse_hash;
6921 sort_by_digest = sort_by_digest_4_4;
6922 opti_type = OPTI_TYPE_ZERO_BYTE
6923 | OPTI_TYPE_PRECOMPUTE_INIT
6924 | OPTI_TYPE_PRECOMPUTE_MERKLE
6925 | OPTI_TYPE_MEET_IN_MIDDLE
6926 | OPTI_TYPE_EARLY_SKIP
6927 | OPTI_TYPE_NOT_ITERATED
6928 | OPTI_TYPE_APPENDED_SALT
6929 | OPTI_TYPE_RAW_HASH;
6930 dgst_pos0 = 0;
6931 dgst_pos1 = 3;
6932 dgst_pos2 = 2;
6933 dgst_pos3 = 1;
6934 break;
6935
6936 case 20: hash_type = HASH_TYPE_MD5;
6937 salt_type = SALT_TYPE_INTERN;
6938 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6939 opts_type = OPTS_TYPE_PT_GENERATE_LE
6940 | OPTS_TYPE_PT_ADD80
6941 | OPTS_TYPE_PT_ADDBITS14;
6942 kern_type = KERN_TYPE_MD5_SLTPW;
6943 dgst_size = DGST_SIZE_4_4;
6944 parse_func = md5s_parse_hash;
6945 sort_by_digest = sort_by_digest_4_4;
6946 opti_type = OPTI_TYPE_ZERO_BYTE
6947 | OPTI_TYPE_PRECOMPUTE_INIT
6948 | OPTI_TYPE_PRECOMPUTE_MERKLE
6949 | OPTI_TYPE_EARLY_SKIP
6950 | OPTI_TYPE_NOT_ITERATED
6951 | OPTI_TYPE_PREPENDED_SALT
6952 | OPTI_TYPE_RAW_HASH;
6953 dgst_pos0 = 0;
6954 dgst_pos1 = 3;
6955 dgst_pos2 = 2;
6956 dgst_pos3 = 1;
6957 break;
6958
6959 case 21: hash_type = HASH_TYPE_MD5;
6960 salt_type = SALT_TYPE_INTERN;
6961 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6962 opts_type = OPTS_TYPE_PT_GENERATE_LE
6963 | OPTS_TYPE_PT_ADD80
6964 | OPTS_TYPE_PT_ADDBITS14;
6965 kern_type = KERN_TYPE_MD5_SLTPW;
6966 dgst_size = DGST_SIZE_4_4;
6967 parse_func = osc_parse_hash;
6968 sort_by_digest = sort_by_digest_4_4;
6969 opti_type = OPTI_TYPE_ZERO_BYTE
6970 | OPTI_TYPE_PRECOMPUTE_INIT
6971 | OPTI_TYPE_PRECOMPUTE_MERKLE
6972 | OPTI_TYPE_EARLY_SKIP
6973 | OPTI_TYPE_NOT_ITERATED
6974 | OPTI_TYPE_PREPENDED_SALT
6975 | OPTI_TYPE_RAW_HASH;
6976 dgst_pos0 = 0;
6977 dgst_pos1 = 3;
6978 dgst_pos2 = 2;
6979 dgst_pos3 = 1;
6980 break;
6981
6982 case 22: hash_type = HASH_TYPE_MD5;
6983 salt_type = SALT_TYPE_EMBEDDED;
6984 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6985 opts_type = OPTS_TYPE_PT_GENERATE_LE
6986 | OPTS_TYPE_PT_ADD80
6987 | OPTS_TYPE_PT_ADDBITS14;
6988 kern_type = KERN_TYPE_MD5_SLTPW;
6989 dgst_size = DGST_SIZE_4_4;
6990 parse_func = netscreen_parse_hash;
6991 sort_by_digest = sort_by_digest_4_4;
6992 opti_type = OPTI_TYPE_ZERO_BYTE
6993 | OPTI_TYPE_PRECOMPUTE_INIT
6994 | OPTI_TYPE_PRECOMPUTE_MERKLE
6995 | OPTI_TYPE_EARLY_SKIP
6996 | OPTI_TYPE_NOT_ITERATED
6997 | OPTI_TYPE_PREPENDED_SALT
6998 | OPTI_TYPE_RAW_HASH;
6999 dgst_pos0 = 0;
7000 dgst_pos1 = 3;
7001 dgst_pos2 = 2;
7002 dgst_pos3 = 1;
7003 break;
7004
7005 case 23: hash_type = HASH_TYPE_MD5;
7006 salt_type = SALT_TYPE_EMBEDDED;
7007 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7008 opts_type = OPTS_TYPE_PT_GENERATE_LE
7009 | OPTS_TYPE_PT_ADD80
7010 | OPTS_TYPE_PT_ADDBITS14;
7011 kern_type = KERN_TYPE_MD5_SLTPW;
7012 dgst_size = DGST_SIZE_4_4;
7013 parse_func = skype_parse_hash;
7014 sort_by_digest = sort_by_digest_4_4;
7015 opti_type = OPTI_TYPE_ZERO_BYTE
7016 | OPTI_TYPE_PRECOMPUTE_INIT
7017 | OPTI_TYPE_PRECOMPUTE_MERKLE
7018 | OPTI_TYPE_EARLY_SKIP
7019 | OPTI_TYPE_NOT_ITERATED
7020 | OPTI_TYPE_PREPENDED_SALT
7021 | OPTI_TYPE_RAW_HASH;
7022 dgst_pos0 = 0;
7023 dgst_pos1 = 3;
7024 dgst_pos2 = 2;
7025 dgst_pos3 = 1;
7026 break;
7027
7028 case 30: hash_type = HASH_TYPE_MD5;
7029 salt_type = SALT_TYPE_INTERN;
7030 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7031 opts_type = OPTS_TYPE_PT_GENERATE_LE
7032 | OPTS_TYPE_PT_UNICODE
7033 | OPTS_TYPE_ST_ADD80
7034 | OPTS_TYPE_ST_ADDBITS14;
7035 kern_type = KERN_TYPE_MD5_PWUSLT;
7036 dgst_size = DGST_SIZE_4_4;
7037 parse_func = md5s_parse_hash;
7038 sort_by_digest = sort_by_digest_4_4;
7039 opti_type = OPTI_TYPE_ZERO_BYTE
7040 | OPTI_TYPE_PRECOMPUTE_INIT
7041 | OPTI_TYPE_PRECOMPUTE_MERKLE
7042 | OPTI_TYPE_MEET_IN_MIDDLE
7043 | OPTI_TYPE_EARLY_SKIP
7044 | OPTI_TYPE_NOT_ITERATED
7045 | OPTI_TYPE_APPENDED_SALT
7046 | OPTI_TYPE_RAW_HASH;
7047 dgst_pos0 = 0;
7048 dgst_pos1 = 3;
7049 dgst_pos2 = 2;
7050 dgst_pos3 = 1;
7051 break;
7052
7053 case 40: hash_type = HASH_TYPE_MD5;
7054 salt_type = SALT_TYPE_INTERN;
7055 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7056 opts_type = OPTS_TYPE_PT_GENERATE_LE
7057 | OPTS_TYPE_PT_ADD80
7058 | OPTS_TYPE_PT_ADDBITS14
7059 | OPTS_TYPE_PT_UNICODE;
7060 kern_type = KERN_TYPE_MD5_SLTPWU;
7061 dgst_size = DGST_SIZE_4_4;
7062 parse_func = md5s_parse_hash;
7063 sort_by_digest = sort_by_digest_4_4;
7064 opti_type = OPTI_TYPE_ZERO_BYTE
7065 | OPTI_TYPE_PRECOMPUTE_INIT
7066 | OPTI_TYPE_PRECOMPUTE_MERKLE
7067 | OPTI_TYPE_EARLY_SKIP
7068 | OPTI_TYPE_NOT_ITERATED
7069 | OPTI_TYPE_PREPENDED_SALT
7070 | OPTI_TYPE_RAW_HASH;
7071 dgst_pos0 = 0;
7072 dgst_pos1 = 3;
7073 dgst_pos2 = 2;
7074 dgst_pos3 = 1;
7075 break;
7076
7077 case 50: hash_type = HASH_TYPE_MD5;
7078 salt_type = SALT_TYPE_INTERN;
7079 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7080 opts_type = OPTS_TYPE_PT_GENERATE_LE
7081 | OPTS_TYPE_ST_ADD80
7082 | OPTS_TYPE_ST_ADDBITS14;
7083 kern_type = KERN_TYPE_HMACMD5_PW;
7084 dgst_size = DGST_SIZE_4_4;
7085 parse_func = hmacmd5_parse_hash;
7086 sort_by_digest = sort_by_digest_4_4;
7087 opti_type = OPTI_TYPE_ZERO_BYTE
7088 | OPTI_TYPE_NOT_ITERATED;
7089 dgst_pos0 = 0;
7090 dgst_pos1 = 3;
7091 dgst_pos2 = 2;
7092 dgst_pos3 = 1;
7093 break;
7094
7095 case 60: hash_type = HASH_TYPE_MD5;
7096 salt_type = SALT_TYPE_INTERN;
7097 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7098 opts_type = OPTS_TYPE_PT_GENERATE_LE
7099 | OPTS_TYPE_PT_ADD80
7100 | OPTS_TYPE_PT_ADDBITS14;
7101 kern_type = KERN_TYPE_HMACMD5_SLT;
7102 dgst_size = DGST_SIZE_4_4;
7103 parse_func = hmacmd5_parse_hash;
7104 sort_by_digest = sort_by_digest_4_4;
7105 opti_type = OPTI_TYPE_ZERO_BYTE
7106 | OPTI_TYPE_NOT_ITERATED;
7107 dgst_pos0 = 0;
7108 dgst_pos1 = 3;
7109 dgst_pos2 = 2;
7110 dgst_pos3 = 1;
7111 break;
7112
7113 case 100: hash_type = HASH_TYPE_SHA1;
7114 salt_type = SALT_TYPE_NONE;
7115 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7116 opts_type = OPTS_TYPE_PT_GENERATE_BE
7117 | OPTS_TYPE_PT_ADD80
7118 | OPTS_TYPE_PT_ADDBITS15;
7119 kern_type = KERN_TYPE_SHA1;
7120 dgst_size = DGST_SIZE_4_5;
7121 parse_func = sha1_parse_hash;
7122 sort_by_digest = sort_by_digest_4_5;
7123 opti_type = OPTI_TYPE_ZERO_BYTE
7124 | OPTI_TYPE_PRECOMPUTE_INIT
7125 | OPTI_TYPE_PRECOMPUTE_MERKLE
7126 | OPTI_TYPE_EARLY_SKIP
7127 | OPTI_TYPE_NOT_ITERATED
7128 | OPTI_TYPE_NOT_SALTED
7129 | OPTI_TYPE_RAW_HASH;
7130 dgst_pos0 = 3;
7131 dgst_pos1 = 4;
7132 dgst_pos2 = 2;
7133 dgst_pos3 = 1;
7134 break;
7135
7136 case 101: hash_type = HASH_TYPE_SHA1;
7137 salt_type = SALT_TYPE_NONE;
7138 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7139 opts_type = OPTS_TYPE_PT_GENERATE_BE
7140 | OPTS_TYPE_PT_ADD80
7141 | OPTS_TYPE_PT_ADDBITS15;
7142 kern_type = KERN_TYPE_SHA1;
7143 dgst_size = DGST_SIZE_4_5;
7144 parse_func = sha1b64_parse_hash;
7145 sort_by_digest = sort_by_digest_4_5;
7146 opti_type = OPTI_TYPE_ZERO_BYTE
7147 | OPTI_TYPE_PRECOMPUTE_INIT
7148 | OPTI_TYPE_PRECOMPUTE_MERKLE
7149 | OPTI_TYPE_EARLY_SKIP
7150 | OPTI_TYPE_NOT_ITERATED
7151 | OPTI_TYPE_NOT_SALTED
7152 | OPTI_TYPE_RAW_HASH;
7153 dgst_pos0 = 3;
7154 dgst_pos1 = 4;
7155 dgst_pos2 = 2;
7156 dgst_pos3 = 1;
7157 break;
7158
7159 case 110: hash_type = HASH_TYPE_SHA1;
7160 salt_type = SALT_TYPE_INTERN;
7161 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7162 opts_type = OPTS_TYPE_PT_GENERATE_BE
7163 | OPTS_TYPE_ST_ADD80
7164 | OPTS_TYPE_ST_ADDBITS15;
7165 kern_type = KERN_TYPE_SHA1_PWSLT;
7166 dgst_size = DGST_SIZE_4_5;
7167 parse_func = sha1s_parse_hash;
7168 sort_by_digest = sort_by_digest_4_5;
7169 opti_type = OPTI_TYPE_ZERO_BYTE
7170 | OPTI_TYPE_PRECOMPUTE_INIT
7171 | OPTI_TYPE_PRECOMPUTE_MERKLE
7172 | OPTI_TYPE_EARLY_SKIP
7173 | OPTI_TYPE_NOT_ITERATED
7174 | OPTI_TYPE_APPENDED_SALT
7175 | OPTI_TYPE_RAW_HASH;
7176 dgst_pos0 = 3;
7177 dgst_pos1 = 4;
7178 dgst_pos2 = 2;
7179 dgst_pos3 = 1;
7180 break;
7181
7182 case 111: hash_type = HASH_TYPE_SHA1;
7183 salt_type = SALT_TYPE_EMBEDDED;
7184 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7185 opts_type = OPTS_TYPE_PT_GENERATE_BE
7186 | OPTS_TYPE_ST_ADD80
7187 | OPTS_TYPE_ST_ADDBITS15;
7188 kern_type = KERN_TYPE_SHA1_PWSLT;
7189 dgst_size = DGST_SIZE_4_5;
7190 parse_func = sha1b64s_parse_hash;
7191 sort_by_digest = sort_by_digest_4_5;
7192 opti_type = OPTI_TYPE_ZERO_BYTE
7193 | OPTI_TYPE_PRECOMPUTE_INIT
7194 | OPTI_TYPE_PRECOMPUTE_MERKLE
7195 | OPTI_TYPE_EARLY_SKIP
7196 | OPTI_TYPE_NOT_ITERATED
7197 | OPTI_TYPE_APPENDED_SALT
7198 | OPTI_TYPE_RAW_HASH;
7199 dgst_pos0 = 3;
7200 dgst_pos1 = 4;
7201 dgst_pos2 = 2;
7202 dgst_pos3 = 1;
7203 break;
7204
7205 case 112: hash_type = HASH_TYPE_SHA1;
7206 salt_type = SALT_TYPE_INTERN;
7207 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7208 opts_type = OPTS_TYPE_PT_GENERATE_BE
7209 | OPTS_TYPE_ST_ADD80
7210 | OPTS_TYPE_ST_ADDBITS15
7211 | OPTS_TYPE_ST_HEX;
7212 kern_type = KERN_TYPE_SHA1_PWSLT;
7213 dgst_size = DGST_SIZE_4_5;
7214 parse_func = oracles_parse_hash;
7215 sort_by_digest = sort_by_digest_4_5;
7216 opti_type = OPTI_TYPE_ZERO_BYTE
7217 | OPTI_TYPE_PRECOMPUTE_INIT
7218 | OPTI_TYPE_PRECOMPUTE_MERKLE
7219 | OPTI_TYPE_EARLY_SKIP
7220 | OPTI_TYPE_NOT_ITERATED
7221 | OPTI_TYPE_APPENDED_SALT
7222 | OPTI_TYPE_RAW_HASH;
7223 dgst_pos0 = 3;
7224 dgst_pos1 = 4;
7225 dgst_pos2 = 2;
7226 dgst_pos3 = 1;
7227 break;
7228
7229 case 120: hash_type = HASH_TYPE_SHA1;
7230 salt_type = SALT_TYPE_INTERN;
7231 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7232 opts_type = OPTS_TYPE_PT_GENERATE_BE
7233 | OPTS_TYPE_PT_ADD80
7234 | OPTS_TYPE_PT_ADDBITS15;
7235 kern_type = KERN_TYPE_SHA1_SLTPW;
7236 dgst_size = DGST_SIZE_4_5;
7237 parse_func = sha1s_parse_hash;
7238 sort_by_digest = sort_by_digest_4_5;
7239 opti_type = OPTI_TYPE_ZERO_BYTE
7240 | OPTI_TYPE_PRECOMPUTE_INIT
7241 | OPTI_TYPE_PRECOMPUTE_MERKLE
7242 | OPTI_TYPE_EARLY_SKIP
7243 | OPTI_TYPE_NOT_ITERATED
7244 | OPTI_TYPE_PREPENDED_SALT
7245 | OPTI_TYPE_RAW_HASH;
7246 dgst_pos0 = 3;
7247 dgst_pos1 = 4;
7248 dgst_pos2 = 2;
7249 dgst_pos3 = 1;
7250 break;
7251
7252 case 121: hash_type = HASH_TYPE_SHA1;
7253 salt_type = SALT_TYPE_INTERN;
7254 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7255 opts_type = OPTS_TYPE_PT_GENERATE_BE
7256 | OPTS_TYPE_PT_ADD80
7257 | OPTS_TYPE_PT_ADDBITS15
7258 | OPTS_TYPE_ST_LOWER;
7259 kern_type = KERN_TYPE_SHA1_SLTPW;
7260 dgst_size = DGST_SIZE_4_5;
7261 parse_func = smf_parse_hash;
7262 sort_by_digest = sort_by_digest_4_5;
7263 opti_type = OPTI_TYPE_ZERO_BYTE
7264 | OPTI_TYPE_PRECOMPUTE_INIT
7265 | OPTI_TYPE_PRECOMPUTE_MERKLE
7266 | OPTI_TYPE_EARLY_SKIP
7267 | OPTI_TYPE_NOT_ITERATED
7268 | OPTI_TYPE_PREPENDED_SALT
7269 | OPTI_TYPE_RAW_HASH;
7270 dgst_pos0 = 3;
7271 dgst_pos1 = 4;
7272 dgst_pos2 = 2;
7273 dgst_pos3 = 1;
7274 break;
7275
7276 case 122: hash_type = HASH_TYPE_SHA1;
7277 salt_type = SALT_TYPE_EMBEDDED;
7278 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7279 opts_type = OPTS_TYPE_PT_GENERATE_BE
7280 | OPTS_TYPE_PT_ADD80
7281 | OPTS_TYPE_PT_ADDBITS15
7282 | OPTS_TYPE_ST_HEX;
7283 kern_type = KERN_TYPE_SHA1_SLTPW;
7284 dgst_size = DGST_SIZE_4_5;
7285 parse_func = osx1_parse_hash;
7286 sort_by_digest = sort_by_digest_4_5;
7287 opti_type = OPTI_TYPE_ZERO_BYTE
7288 | OPTI_TYPE_PRECOMPUTE_INIT
7289 | OPTI_TYPE_PRECOMPUTE_MERKLE
7290 | OPTI_TYPE_EARLY_SKIP
7291 | OPTI_TYPE_NOT_ITERATED
7292 | OPTI_TYPE_PREPENDED_SALT
7293 | OPTI_TYPE_RAW_HASH;
7294 dgst_pos0 = 3;
7295 dgst_pos1 = 4;
7296 dgst_pos2 = 2;
7297 dgst_pos3 = 1;
7298 break;
7299
7300 case 124: hash_type = HASH_TYPE_SHA1;
7301 salt_type = SALT_TYPE_EMBEDDED;
7302 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7303 opts_type = OPTS_TYPE_PT_GENERATE_BE
7304 | OPTS_TYPE_PT_ADD80
7305 | OPTS_TYPE_PT_ADDBITS15;
7306 kern_type = KERN_TYPE_SHA1_SLTPW;
7307 dgst_size = DGST_SIZE_4_5;
7308 parse_func = djangosha1_parse_hash;
7309 sort_by_digest = sort_by_digest_4_5;
7310 opti_type = OPTI_TYPE_ZERO_BYTE
7311 | OPTI_TYPE_PRECOMPUTE_INIT
7312 | OPTI_TYPE_PRECOMPUTE_MERKLE
7313 | OPTI_TYPE_EARLY_SKIP
7314 | OPTI_TYPE_NOT_ITERATED
7315 | OPTI_TYPE_PREPENDED_SALT
7316 | OPTI_TYPE_RAW_HASH;
7317 dgst_pos0 = 3;
7318 dgst_pos1 = 4;
7319 dgst_pos2 = 2;
7320 dgst_pos3 = 1;
7321 break;
7322
7323 case 125: hash_type = HASH_TYPE_SHA1;
7324 salt_type = SALT_TYPE_EMBEDDED;
7325 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7326 opts_type = OPTS_TYPE_PT_GENERATE_BE
7327 | OPTS_TYPE_PT_ADD80
7328 | OPTS_TYPE_PT_ADDBITS15
7329 | OPTS_TYPE_ST_HEX;
7330 kern_type = KERN_TYPE_SHA1_SLTPW;
7331 dgst_size = DGST_SIZE_4_5;
7332 parse_func = arubaos_parse_hash;
7333 sort_by_digest = sort_by_digest_4_5;
7334 opti_type = OPTI_TYPE_ZERO_BYTE
7335 | OPTI_TYPE_PRECOMPUTE_INIT
7336 | OPTI_TYPE_PRECOMPUTE_MERKLE
7337 | OPTI_TYPE_EARLY_SKIP
7338 | OPTI_TYPE_NOT_ITERATED
7339 | OPTI_TYPE_PREPENDED_SALT
7340 | OPTI_TYPE_RAW_HASH;
7341 dgst_pos0 = 3;
7342 dgst_pos1 = 4;
7343 dgst_pos2 = 2;
7344 dgst_pos3 = 1;
7345 break;
7346
7347 case 130: hash_type = HASH_TYPE_SHA1;
7348 salt_type = SALT_TYPE_INTERN;
7349 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7350 opts_type = OPTS_TYPE_PT_GENERATE_BE
7351 | OPTS_TYPE_PT_UNICODE
7352 | OPTS_TYPE_ST_ADD80
7353 | OPTS_TYPE_ST_ADDBITS15;
7354 kern_type = KERN_TYPE_SHA1_PWUSLT;
7355 dgst_size = DGST_SIZE_4_5;
7356 parse_func = sha1s_parse_hash;
7357 sort_by_digest = sort_by_digest_4_5;
7358 opti_type = OPTI_TYPE_ZERO_BYTE
7359 | OPTI_TYPE_PRECOMPUTE_INIT
7360 | OPTI_TYPE_PRECOMPUTE_MERKLE
7361 | OPTI_TYPE_EARLY_SKIP
7362 | OPTI_TYPE_NOT_ITERATED
7363 | OPTI_TYPE_APPENDED_SALT
7364 | OPTI_TYPE_RAW_HASH;
7365 dgst_pos0 = 3;
7366 dgst_pos1 = 4;
7367 dgst_pos2 = 2;
7368 dgst_pos3 = 1;
7369 break;
7370
7371 case 131: hash_type = HASH_TYPE_SHA1;
7372 salt_type = SALT_TYPE_EMBEDDED;
7373 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7374 opts_type = OPTS_TYPE_PT_GENERATE_BE
7375 | OPTS_TYPE_PT_UNICODE
7376 | OPTS_TYPE_PT_UPPER
7377 | OPTS_TYPE_ST_ADD80
7378 | OPTS_TYPE_ST_ADDBITS15
7379 | OPTS_TYPE_ST_HEX;
7380 kern_type = KERN_TYPE_SHA1_PWUSLT;
7381 dgst_size = DGST_SIZE_4_5;
7382 parse_func = mssql2000_parse_hash;
7383 sort_by_digest = sort_by_digest_4_5;
7384 opti_type = OPTI_TYPE_ZERO_BYTE
7385 | OPTI_TYPE_PRECOMPUTE_INIT
7386 | OPTI_TYPE_PRECOMPUTE_MERKLE
7387 | OPTI_TYPE_EARLY_SKIP
7388 | OPTI_TYPE_NOT_ITERATED
7389 | OPTI_TYPE_APPENDED_SALT
7390 | OPTI_TYPE_RAW_HASH;
7391 dgst_pos0 = 3;
7392 dgst_pos1 = 4;
7393 dgst_pos2 = 2;
7394 dgst_pos3 = 1;
7395 break;
7396
7397 case 132: hash_type = HASH_TYPE_SHA1;
7398 salt_type = SALT_TYPE_EMBEDDED;
7399 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7400 opts_type = OPTS_TYPE_PT_GENERATE_BE
7401 | OPTS_TYPE_PT_UNICODE
7402 | OPTS_TYPE_ST_ADD80
7403 | OPTS_TYPE_ST_ADDBITS15
7404 | OPTS_TYPE_ST_HEX;
7405 kern_type = KERN_TYPE_SHA1_PWUSLT;
7406 dgst_size = DGST_SIZE_4_5;
7407 parse_func = mssql2005_parse_hash;
7408 sort_by_digest = sort_by_digest_4_5;
7409 opti_type = OPTI_TYPE_ZERO_BYTE
7410 | OPTI_TYPE_PRECOMPUTE_INIT
7411 | OPTI_TYPE_PRECOMPUTE_MERKLE
7412 | OPTI_TYPE_EARLY_SKIP
7413 | OPTI_TYPE_NOT_ITERATED
7414 | OPTI_TYPE_APPENDED_SALT
7415 | OPTI_TYPE_RAW_HASH;
7416 dgst_pos0 = 3;
7417 dgst_pos1 = 4;
7418 dgst_pos2 = 2;
7419 dgst_pos3 = 1;
7420 break;
7421
7422 case 133: hash_type = HASH_TYPE_SHA1;
7423 salt_type = SALT_TYPE_EMBEDDED;
7424 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7425 opts_type = OPTS_TYPE_PT_GENERATE_BE
7426 | OPTS_TYPE_PT_UNICODE
7427 | OPTS_TYPE_ST_ADD80
7428 | OPTS_TYPE_ST_ADDBITS15;
7429 kern_type = KERN_TYPE_SHA1_PWUSLT;
7430 dgst_size = DGST_SIZE_4_5;
7431 parse_func = peoplesoft_parse_hash;
7432 sort_by_digest = sort_by_digest_4_5;
7433 opti_type = OPTI_TYPE_ZERO_BYTE
7434 | OPTI_TYPE_PRECOMPUTE_INIT
7435 | OPTI_TYPE_PRECOMPUTE_MERKLE
7436 | OPTI_TYPE_EARLY_SKIP
7437 | OPTI_TYPE_NOT_ITERATED
7438 | OPTI_TYPE_APPENDED_SALT
7439 | OPTI_TYPE_RAW_HASH;
7440 dgst_pos0 = 3;
7441 dgst_pos1 = 4;
7442 dgst_pos2 = 2;
7443 dgst_pos3 = 1;
7444 break;
7445
7446 case 140: hash_type = HASH_TYPE_SHA1;
7447 salt_type = SALT_TYPE_INTERN;
7448 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7449 opts_type = OPTS_TYPE_PT_GENERATE_BE
7450 | OPTS_TYPE_PT_ADD80
7451 | OPTS_TYPE_PT_ADDBITS15
7452 | OPTS_TYPE_PT_UNICODE;
7453 kern_type = KERN_TYPE_SHA1_SLTPWU;
7454 dgst_size = DGST_SIZE_4_5;
7455 parse_func = sha1s_parse_hash;
7456 sort_by_digest = sort_by_digest_4_5;
7457 opti_type = OPTI_TYPE_ZERO_BYTE
7458 | OPTI_TYPE_PRECOMPUTE_INIT
7459 | OPTI_TYPE_PRECOMPUTE_MERKLE
7460 | OPTI_TYPE_EARLY_SKIP
7461 | OPTI_TYPE_NOT_ITERATED
7462 | OPTI_TYPE_PREPENDED_SALT
7463 | OPTI_TYPE_RAW_HASH;
7464 dgst_pos0 = 3;
7465 dgst_pos1 = 4;
7466 dgst_pos2 = 2;
7467 dgst_pos3 = 1;
7468 break;
7469
7470 case 141: hash_type = HASH_TYPE_SHA1;
7471 salt_type = SALT_TYPE_EMBEDDED;
7472 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7473 opts_type = OPTS_TYPE_PT_GENERATE_BE
7474 | OPTS_TYPE_PT_ADD80
7475 | OPTS_TYPE_PT_ADDBITS15
7476 | OPTS_TYPE_PT_UNICODE
7477 | OPTS_TYPE_ST_BASE64;
7478 kern_type = KERN_TYPE_SHA1_SLTPWU;
7479 dgst_size = DGST_SIZE_4_5;
7480 parse_func = episerver_parse_hash;
7481 sort_by_digest = sort_by_digest_4_5;
7482 opti_type = OPTI_TYPE_ZERO_BYTE
7483 | OPTI_TYPE_PRECOMPUTE_INIT
7484 | OPTI_TYPE_PRECOMPUTE_MERKLE
7485 | OPTI_TYPE_EARLY_SKIP
7486 | OPTI_TYPE_NOT_ITERATED
7487 | OPTI_TYPE_PREPENDED_SALT
7488 | OPTI_TYPE_RAW_HASH;
7489 dgst_pos0 = 3;
7490 dgst_pos1 = 4;
7491 dgst_pos2 = 2;
7492 dgst_pos3 = 1;
7493 break;
7494
7495 case 150: hash_type = HASH_TYPE_SHA1;
7496 salt_type = SALT_TYPE_INTERN;
7497 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7498 opts_type = OPTS_TYPE_PT_GENERATE_BE
7499 | OPTS_TYPE_ST_ADD80
7500 | OPTS_TYPE_ST_ADDBITS15;
7501 kern_type = KERN_TYPE_HMACSHA1_PW;
7502 dgst_size = DGST_SIZE_4_5;
7503 parse_func = hmacsha1_parse_hash;
7504 sort_by_digest = sort_by_digest_4_5;
7505 opti_type = OPTI_TYPE_ZERO_BYTE
7506 | OPTI_TYPE_NOT_ITERATED;
7507 dgst_pos0 = 3;
7508 dgst_pos1 = 4;
7509 dgst_pos2 = 2;
7510 dgst_pos3 = 1;
7511 break;
7512
7513 case 160: hash_type = HASH_TYPE_SHA1;
7514 salt_type = SALT_TYPE_INTERN;
7515 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7516 opts_type = OPTS_TYPE_PT_GENERATE_BE
7517 | OPTS_TYPE_PT_ADD80
7518 | OPTS_TYPE_PT_ADDBITS15;
7519 kern_type = KERN_TYPE_HMACSHA1_SLT;
7520 dgst_size = DGST_SIZE_4_5;
7521 parse_func = hmacsha1_parse_hash;
7522 sort_by_digest = sort_by_digest_4_5;
7523 opti_type = OPTI_TYPE_ZERO_BYTE
7524 | OPTI_TYPE_NOT_ITERATED;
7525 dgst_pos0 = 3;
7526 dgst_pos1 = 4;
7527 dgst_pos2 = 2;
7528 dgst_pos3 = 1;
7529 break;
7530
7531 case 190: hash_type = HASH_TYPE_SHA1;
7532 salt_type = SALT_TYPE_NONE;
7533 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7534 opts_type = OPTS_TYPE_PT_GENERATE_BE
7535 | OPTS_TYPE_PT_ADD80
7536 | OPTS_TYPE_PT_ADDBITS15;
7537 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7538 dgst_size = DGST_SIZE_4_5;
7539 parse_func = sha1linkedin_parse_hash;
7540 sort_by_digest = sort_by_digest_4_5;
7541 opti_type = OPTI_TYPE_ZERO_BYTE
7542 | OPTI_TYPE_PRECOMPUTE_INIT
7543 | OPTI_TYPE_EARLY_SKIP
7544 | OPTI_TYPE_NOT_ITERATED
7545 | OPTI_TYPE_NOT_SALTED;
7546 dgst_pos0 = 0;
7547 dgst_pos1 = 4;
7548 dgst_pos2 = 3;
7549 dgst_pos3 = 2;
7550 break;
7551
7552 case 200: hash_type = HASH_TYPE_MYSQL;
7553 salt_type = SALT_TYPE_NONE;
7554 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7555 opts_type = 0;
7556 kern_type = KERN_TYPE_MYSQL;
7557 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7558 parse_func = mysql323_parse_hash;
7559 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7560 opti_type = OPTI_TYPE_ZERO_BYTE;
7561 dgst_pos0 = 0;
7562 dgst_pos1 = 1;
7563 dgst_pos2 = 2;
7564 dgst_pos3 = 3;
7565 break;
7566
7567 case 300: hash_type = HASH_TYPE_SHA1;
7568 salt_type = SALT_TYPE_NONE;
7569 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7570 opts_type = OPTS_TYPE_PT_GENERATE_BE
7571 | OPTS_TYPE_PT_ADD80
7572 | OPTS_TYPE_PT_ADDBITS15;
7573 kern_type = KERN_TYPE_MYSQL41;
7574 dgst_size = DGST_SIZE_4_5;
7575 parse_func = sha1_parse_hash;
7576 sort_by_digest = sort_by_digest_4_5;
7577 opti_type = OPTI_TYPE_ZERO_BYTE
7578 | OPTI_TYPE_PRECOMPUTE_INIT
7579 | OPTI_TYPE_PRECOMPUTE_MERKLE
7580 | OPTI_TYPE_EARLY_SKIP
7581 | OPTI_TYPE_NOT_ITERATED
7582 | OPTI_TYPE_NOT_SALTED;
7583 dgst_pos0 = 3;
7584 dgst_pos1 = 4;
7585 dgst_pos2 = 2;
7586 dgst_pos3 = 1;
7587 break;
7588
7589 case 400: hash_type = HASH_TYPE_MD5;
7590 salt_type = SALT_TYPE_EMBEDDED;
7591 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7592 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7593 kern_type = KERN_TYPE_PHPASS;
7594 dgst_size = DGST_SIZE_4_4;
7595 parse_func = phpass_parse_hash;
7596 sort_by_digest = sort_by_digest_4_4;
7597 opti_type = OPTI_TYPE_ZERO_BYTE;
7598 dgst_pos0 = 0;
7599 dgst_pos1 = 1;
7600 dgst_pos2 = 2;
7601 dgst_pos3 = 3;
7602 break;
7603
7604 case 500: hash_type = HASH_TYPE_MD5;
7605 salt_type = SALT_TYPE_EMBEDDED;
7606 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7607 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7608 kern_type = KERN_TYPE_MD5CRYPT;
7609 dgst_size = DGST_SIZE_4_4;
7610 parse_func = md5crypt_parse_hash;
7611 sort_by_digest = sort_by_digest_4_4;
7612 opti_type = OPTI_TYPE_ZERO_BYTE;
7613 dgst_pos0 = 0;
7614 dgst_pos1 = 1;
7615 dgst_pos2 = 2;
7616 dgst_pos3 = 3;
7617 break;
7618
7619 case 501: hash_type = HASH_TYPE_MD5;
7620 salt_type = SALT_TYPE_EMBEDDED;
7621 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7622 opts_type = OPTS_TYPE_PT_GENERATE_LE
7623 | OPTS_TYPE_HASH_COPY;
7624 kern_type = KERN_TYPE_MD5CRYPT;
7625 dgst_size = DGST_SIZE_4_4;
7626 parse_func = juniper_parse_hash;
7627 sort_by_digest = sort_by_digest_4_4;
7628 opti_type = OPTI_TYPE_ZERO_BYTE;
7629 dgst_pos0 = 0;
7630 dgst_pos1 = 1;
7631 dgst_pos2 = 2;
7632 dgst_pos3 = 3;
7633 break;
7634
7635 case 900: hash_type = HASH_TYPE_MD4;
7636 salt_type = SALT_TYPE_NONE;
7637 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7638 opts_type = OPTS_TYPE_PT_GENERATE_LE
7639 | OPTS_TYPE_PT_ADD80
7640 | OPTS_TYPE_PT_ADDBITS14;
7641 kern_type = KERN_TYPE_MD4;
7642 dgst_size = DGST_SIZE_4_4;
7643 parse_func = md4_parse_hash;
7644 sort_by_digest = sort_by_digest_4_4;
7645 opti_type = OPTI_TYPE_ZERO_BYTE
7646 | OPTI_TYPE_PRECOMPUTE_INIT
7647 | OPTI_TYPE_PRECOMPUTE_MERKLE
7648 | OPTI_TYPE_MEET_IN_MIDDLE
7649 | OPTI_TYPE_EARLY_SKIP
7650 | OPTI_TYPE_NOT_ITERATED
7651 | OPTI_TYPE_NOT_SALTED
7652 | OPTI_TYPE_RAW_HASH;
7653 dgst_pos0 = 0;
7654 dgst_pos1 = 3;
7655 dgst_pos2 = 2;
7656 dgst_pos3 = 1;
7657 break;
7658
7659 case 1000: hash_type = HASH_TYPE_MD4;
7660 salt_type = SALT_TYPE_NONE;
7661 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7662 opts_type = OPTS_TYPE_PT_GENERATE_LE
7663 | OPTS_TYPE_PT_ADD80
7664 | OPTS_TYPE_PT_ADDBITS14
7665 | OPTS_TYPE_PT_UNICODE;
7666 kern_type = KERN_TYPE_MD4_PWU;
7667 dgst_size = DGST_SIZE_4_4;
7668 parse_func = md4_parse_hash;
7669 sort_by_digest = sort_by_digest_4_4;
7670 opti_type = OPTI_TYPE_ZERO_BYTE
7671 | OPTI_TYPE_PRECOMPUTE_INIT
7672 | OPTI_TYPE_PRECOMPUTE_MERKLE
7673 | OPTI_TYPE_MEET_IN_MIDDLE
7674 | OPTI_TYPE_EARLY_SKIP
7675 | OPTI_TYPE_NOT_ITERATED
7676 | OPTI_TYPE_NOT_SALTED
7677 | OPTI_TYPE_RAW_HASH;
7678 dgst_pos0 = 0;
7679 dgst_pos1 = 3;
7680 dgst_pos2 = 2;
7681 dgst_pos3 = 1;
7682 break;
7683
7684 case 1100: hash_type = HASH_TYPE_MD4;
7685 salt_type = SALT_TYPE_INTERN;
7686 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7687 opts_type = OPTS_TYPE_PT_GENERATE_LE
7688 | OPTS_TYPE_PT_ADD80
7689 | OPTS_TYPE_PT_ADDBITS14
7690 | OPTS_TYPE_PT_UNICODE
7691 | OPTS_TYPE_ST_ADD80
7692 | OPTS_TYPE_ST_UNICODE
7693 | OPTS_TYPE_ST_LOWER;
7694 kern_type = KERN_TYPE_MD44_PWUSLT;
7695 dgst_size = DGST_SIZE_4_4;
7696 parse_func = dcc_parse_hash;
7697 sort_by_digest = sort_by_digest_4_4;
7698 opti_type = OPTI_TYPE_ZERO_BYTE
7699 | OPTI_TYPE_PRECOMPUTE_INIT
7700 | OPTI_TYPE_PRECOMPUTE_MERKLE
7701 | OPTI_TYPE_EARLY_SKIP
7702 | OPTI_TYPE_NOT_ITERATED;
7703 dgst_pos0 = 0;
7704 dgst_pos1 = 3;
7705 dgst_pos2 = 2;
7706 dgst_pos3 = 1;
7707 break;
7708
7709 case 1400: hash_type = HASH_TYPE_SHA256;
7710 salt_type = SALT_TYPE_NONE;
7711 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7712 opts_type = OPTS_TYPE_PT_GENERATE_BE
7713 | OPTS_TYPE_PT_ADD80
7714 | OPTS_TYPE_PT_ADDBITS15;
7715 kern_type = KERN_TYPE_SHA256;
7716 dgst_size = DGST_SIZE_4_8;
7717 parse_func = sha256_parse_hash;
7718 sort_by_digest = sort_by_digest_4_8;
7719 opti_type = OPTI_TYPE_ZERO_BYTE
7720 | OPTI_TYPE_PRECOMPUTE_INIT
7721 | OPTI_TYPE_PRECOMPUTE_MERKLE
7722 | OPTI_TYPE_EARLY_SKIP
7723 | OPTI_TYPE_NOT_ITERATED
7724 | OPTI_TYPE_NOT_SALTED
7725 | OPTI_TYPE_RAW_HASH;
7726 dgst_pos0 = 3;
7727 dgst_pos1 = 7;
7728 dgst_pos2 = 2;
7729 dgst_pos3 = 6;
7730 break;
7731
7732 case 1410: hash_type = HASH_TYPE_SHA256;
7733 salt_type = SALT_TYPE_INTERN;
7734 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7735 opts_type = OPTS_TYPE_PT_GENERATE_BE
7736 | OPTS_TYPE_ST_ADD80
7737 | OPTS_TYPE_ST_ADDBITS15;
7738 kern_type = KERN_TYPE_SHA256_PWSLT;
7739 dgst_size = DGST_SIZE_4_8;
7740 parse_func = sha256s_parse_hash;
7741 sort_by_digest = sort_by_digest_4_8;
7742 opti_type = OPTI_TYPE_ZERO_BYTE
7743 | OPTI_TYPE_PRECOMPUTE_INIT
7744 | OPTI_TYPE_PRECOMPUTE_MERKLE
7745 | OPTI_TYPE_EARLY_SKIP
7746 | OPTI_TYPE_NOT_ITERATED
7747 | OPTI_TYPE_APPENDED_SALT
7748 | OPTI_TYPE_RAW_HASH;
7749 dgst_pos0 = 3;
7750 dgst_pos1 = 7;
7751 dgst_pos2 = 2;
7752 dgst_pos3 = 6;
7753 break;
7754
7755 case 1420: hash_type = HASH_TYPE_SHA256;
7756 salt_type = SALT_TYPE_INTERN;
7757 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7758 opts_type = OPTS_TYPE_PT_GENERATE_BE
7759 | OPTS_TYPE_PT_ADD80
7760 | OPTS_TYPE_PT_ADDBITS15;
7761 kern_type = KERN_TYPE_SHA256_SLTPW;
7762 dgst_size = DGST_SIZE_4_8;
7763 parse_func = sha256s_parse_hash;
7764 sort_by_digest = sort_by_digest_4_8;
7765 opti_type = OPTI_TYPE_ZERO_BYTE
7766 | OPTI_TYPE_PRECOMPUTE_INIT
7767 | OPTI_TYPE_PRECOMPUTE_MERKLE
7768 | OPTI_TYPE_EARLY_SKIP
7769 | OPTI_TYPE_NOT_ITERATED
7770 | OPTI_TYPE_PREPENDED_SALT
7771 | OPTI_TYPE_RAW_HASH;
7772 dgst_pos0 = 3;
7773 dgst_pos1 = 7;
7774 dgst_pos2 = 2;
7775 dgst_pos3 = 6;
7776 break;
7777
7778 case 1421: hash_type = HASH_TYPE_SHA256;
7779 salt_type = SALT_TYPE_EMBEDDED;
7780 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7781 opts_type = OPTS_TYPE_PT_GENERATE_BE
7782 | OPTS_TYPE_PT_ADD80
7783 | OPTS_TYPE_PT_ADDBITS15;
7784 kern_type = KERN_TYPE_SHA256_SLTPW;
7785 dgst_size = DGST_SIZE_4_8;
7786 parse_func = hmailserver_parse_hash;
7787 sort_by_digest = sort_by_digest_4_8;
7788 opti_type = OPTI_TYPE_ZERO_BYTE
7789 | OPTI_TYPE_PRECOMPUTE_INIT
7790 | OPTI_TYPE_PRECOMPUTE_MERKLE
7791 | OPTI_TYPE_EARLY_SKIP
7792 | OPTI_TYPE_NOT_ITERATED
7793 | OPTI_TYPE_PREPENDED_SALT
7794 | OPTI_TYPE_RAW_HASH;
7795 dgst_pos0 = 3;
7796 dgst_pos1 = 7;
7797 dgst_pos2 = 2;
7798 dgst_pos3 = 6;
7799 break;
7800
7801 case 1430: hash_type = HASH_TYPE_SHA256;
7802 salt_type = SALT_TYPE_INTERN;
7803 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7804 opts_type = OPTS_TYPE_PT_GENERATE_BE
7805 | OPTS_TYPE_PT_UNICODE
7806 | OPTS_TYPE_ST_ADD80
7807 | OPTS_TYPE_ST_ADDBITS15;
7808 kern_type = KERN_TYPE_SHA256_PWUSLT;
7809 dgst_size = DGST_SIZE_4_8;
7810 parse_func = sha256s_parse_hash;
7811 sort_by_digest = sort_by_digest_4_8;
7812 opti_type = OPTI_TYPE_ZERO_BYTE
7813 | OPTI_TYPE_PRECOMPUTE_INIT
7814 | OPTI_TYPE_PRECOMPUTE_MERKLE
7815 | OPTI_TYPE_EARLY_SKIP
7816 | OPTI_TYPE_NOT_ITERATED
7817 | OPTI_TYPE_APPENDED_SALT
7818 | OPTI_TYPE_RAW_HASH;
7819 dgst_pos0 = 3;
7820 dgst_pos1 = 7;
7821 dgst_pos2 = 2;
7822 dgst_pos3 = 6;
7823 break;
7824
7825 case 1440: hash_type = HASH_TYPE_SHA256;
7826 salt_type = SALT_TYPE_INTERN;
7827 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7828 opts_type = OPTS_TYPE_PT_GENERATE_BE
7829 | OPTS_TYPE_PT_ADD80
7830 | OPTS_TYPE_PT_ADDBITS15
7831 | OPTS_TYPE_PT_UNICODE;
7832 kern_type = KERN_TYPE_SHA256_SLTPWU;
7833 dgst_size = DGST_SIZE_4_8;
7834 parse_func = sha256s_parse_hash;
7835 sort_by_digest = sort_by_digest_4_8;
7836 opti_type = OPTI_TYPE_ZERO_BYTE
7837 | OPTI_TYPE_PRECOMPUTE_INIT
7838 | OPTI_TYPE_PRECOMPUTE_MERKLE
7839 | OPTI_TYPE_EARLY_SKIP
7840 | OPTI_TYPE_NOT_ITERATED
7841 | OPTI_TYPE_PREPENDED_SALT
7842 | OPTI_TYPE_RAW_HASH;
7843 dgst_pos0 = 3;
7844 dgst_pos1 = 7;
7845 dgst_pos2 = 2;
7846 dgst_pos3 = 6;
7847 break;
7848
7849 case 1441: hash_type = HASH_TYPE_SHA256;
7850 salt_type = SALT_TYPE_EMBEDDED;
7851 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7852 opts_type = OPTS_TYPE_PT_GENERATE_BE
7853 | OPTS_TYPE_PT_ADD80
7854 | OPTS_TYPE_PT_ADDBITS15
7855 | OPTS_TYPE_PT_UNICODE
7856 | OPTS_TYPE_ST_BASE64;
7857 kern_type = KERN_TYPE_SHA256_SLTPWU;
7858 dgst_size = DGST_SIZE_4_8;
7859 parse_func = episerver4_parse_hash;
7860 sort_by_digest = sort_by_digest_4_8;
7861 opti_type = OPTI_TYPE_ZERO_BYTE
7862 | OPTI_TYPE_PRECOMPUTE_INIT
7863 | OPTI_TYPE_PRECOMPUTE_MERKLE
7864 | OPTI_TYPE_EARLY_SKIP
7865 | OPTI_TYPE_NOT_ITERATED
7866 | OPTI_TYPE_PREPENDED_SALT
7867 | OPTI_TYPE_RAW_HASH;
7868 dgst_pos0 = 3;
7869 dgst_pos1 = 7;
7870 dgst_pos2 = 2;
7871 dgst_pos3 = 6;
7872 break;
7873
7874 case 1450: hash_type = HASH_TYPE_SHA256;
7875 salt_type = SALT_TYPE_INTERN;
7876 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7877 opts_type = OPTS_TYPE_PT_GENERATE_BE
7878 | OPTS_TYPE_ST_ADD80;
7879 kern_type = KERN_TYPE_HMACSHA256_PW;
7880 dgst_size = DGST_SIZE_4_8;
7881 parse_func = hmacsha256_parse_hash;
7882 sort_by_digest = sort_by_digest_4_8;
7883 opti_type = OPTI_TYPE_ZERO_BYTE
7884 | OPTI_TYPE_NOT_ITERATED;
7885 dgst_pos0 = 3;
7886 dgst_pos1 = 7;
7887 dgst_pos2 = 2;
7888 dgst_pos3 = 6;
7889 break;
7890
7891 case 1460: hash_type = HASH_TYPE_SHA256;
7892 salt_type = SALT_TYPE_INTERN;
7893 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7894 opts_type = OPTS_TYPE_PT_GENERATE_BE
7895 | OPTS_TYPE_PT_ADD80
7896 | OPTS_TYPE_PT_ADDBITS15;
7897 kern_type = KERN_TYPE_HMACSHA256_SLT;
7898 dgst_size = DGST_SIZE_4_8;
7899 parse_func = hmacsha256_parse_hash;
7900 sort_by_digest = sort_by_digest_4_8;
7901 opti_type = OPTI_TYPE_ZERO_BYTE
7902 | OPTI_TYPE_NOT_ITERATED;
7903 dgst_pos0 = 3;
7904 dgst_pos1 = 7;
7905 dgst_pos2 = 2;
7906 dgst_pos3 = 6;
7907 break;
7908
7909 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7910 salt_type = SALT_TYPE_EMBEDDED;
7911 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7912 opts_type = OPTS_TYPE_PT_GENERATE_LE
7913 | OPTS_TYPE_PT_BITSLICE;
7914 kern_type = KERN_TYPE_DESCRYPT;
7915 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7916 parse_func = descrypt_parse_hash;
7917 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7918 opti_type = OPTI_TYPE_ZERO_BYTE
7919 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7920 dgst_pos0 = 0;
7921 dgst_pos1 = 1;
7922 dgst_pos2 = 2;
7923 dgst_pos3 = 3;
7924 break;
7925
7926 case 1600: hash_type = HASH_TYPE_MD5;
7927 salt_type = SALT_TYPE_EMBEDDED;
7928 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7929 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7930 kern_type = KERN_TYPE_APR1CRYPT;
7931 dgst_size = DGST_SIZE_4_4;
7932 parse_func = md5apr1_parse_hash;
7933 sort_by_digest = sort_by_digest_4_4;
7934 opti_type = OPTI_TYPE_ZERO_BYTE;
7935 dgst_pos0 = 0;
7936 dgst_pos1 = 1;
7937 dgst_pos2 = 2;
7938 dgst_pos3 = 3;
7939 break;
7940
7941 case 1700: hash_type = HASH_TYPE_SHA512;
7942 salt_type = SALT_TYPE_NONE;
7943 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7944 opts_type = OPTS_TYPE_PT_GENERATE_BE
7945 | OPTS_TYPE_PT_ADD80
7946 | OPTS_TYPE_PT_ADDBITS15;
7947 kern_type = KERN_TYPE_SHA512;
7948 dgst_size = DGST_SIZE_8_8;
7949 parse_func = sha512_parse_hash;
7950 sort_by_digest = sort_by_digest_8_8;
7951 opti_type = OPTI_TYPE_ZERO_BYTE
7952 | OPTI_TYPE_PRECOMPUTE_INIT
7953 | OPTI_TYPE_PRECOMPUTE_MERKLE
7954 | OPTI_TYPE_EARLY_SKIP
7955 | OPTI_TYPE_NOT_ITERATED
7956 | OPTI_TYPE_NOT_SALTED
7957 | OPTI_TYPE_USES_BITS_64
7958 | OPTI_TYPE_RAW_HASH;
7959 dgst_pos0 = 14;
7960 dgst_pos1 = 15;
7961 dgst_pos2 = 6;
7962 dgst_pos3 = 7;
7963 break;
7964
7965 case 1710: hash_type = HASH_TYPE_SHA512;
7966 salt_type = SALT_TYPE_INTERN;
7967 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7968 opts_type = OPTS_TYPE_PT_GENERATE_BE
7969 | OPTS_TYPE_ST_ADD80
7970 | OPTS_TYPE_ST_ADDBITS15;
7971 kern_type = KERN_TYPE_SHA512_PWSLT;
7972 dgst_size = DGST_SIZE_8_8;
7973 parse_func = sha512s_parse_hash;
7974 sort_by_digest = sort_by_digest_8_8;
7975 opti_type = OPTI_TYPE_ZERO_BYTE
7976 | OPTI_TYPE_PRECOMPUTE_INIT
7977 | OPTI_TYPE_PRECOMPUTE_MERKLE
7978 | OPTI_TYPE_EARLY_SKIP
7979 | OPTI_TYPE_NOT_ITERATED
7980 | OPTI_TYPE_APPENDED_SALT
7981 | OPTI_TYPE_USES_BITS_64
7982 | OPTI_TYPE_RAW_HASH;
7983 dgst_pos0 = 14;
7984 dgst_pos1 = 15;
7985 dgst_pos2 = 6;
7986 dgst_pos3 = 7;
7987 break;
7988
7989 case 1711: hash_type = HASH_TYPE_SHA512;
7990 salt_type = SALT_TYPE_EMBEDDED;
7991 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7992 opts_type = OPTS_TYPE_PT_GENERATE_BE
7993 | OPTS_TYPE_ST_ADD80
7994 | OPTS_TYPE_ST_ADDBITS15;
7995 kern_type = KERN_TYPE_SHA512_PWSLT;
7996 dgst_size = DGST_SIZE_8_8;
7997 parse_func = sha512b64s_parse_hash;
7998 sort_by_digest = sort_by_digest_8_8;
7999 opti_type = OPTI_TYPE_ZERO_BYTE
8000 | OPTI_TYPE_PRECOMPUTE_INIT
8001 | OPTI_TYPE_PRECOMPUTE_MERKLE
8002 | OPTI_TYPE_EARLY_SKIP
8003 | OPTI_TYPE_NOT_ITERATED
8004 | OPTI_TYPE_APPENDED_SALT
8005 | OPTI_TYPE_USES_BITS_64
8006 | OPTI_TYPE_RAW_HASH;
8007 dgst_pos0 = 14;
8008 dgst_pos1 = 15;
8009 dgst_pos2 = 6;
8010 dgst_pos3 = 7;
8011 break;
8012
8013 case 1720: hash_type = HASH_TYPE_SHA512;
8014 salt_type = SALT_TYPE_INTERN;
8015 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8016 opts_type = OPTS_TYPE_PT_GENERATE_BE
8017 | OPTS_TYPE_PT_ADD80
8018 | OPTS_TYPE_PT_ADDBITS15;
8019 kern_type = KERN_TYPE_SHA512_SLTPW;
8020 dgst_size = DGST_SIZE_8_8;
8021 parse_func = sha512s_parse_hash;
8022 sort_by_digest = sort_by_digest_8_8;
8023 opti_type = OPTI_TYPE_ZERO_BYTE
8024 | OPTI_TYPE_PRECOMPUTE_INIT
8025 | OPTI_TYPE_PRECOMPUTE_MERKLE
8026 | OPTI_TYPE_EARLY_SKIP
8027 | OPTI_TYPE_NOT_ITERATED
8028 | OPTI_TYPE_PREPENDED_SALT
8029 | OPTI_TYPE_USES_BITS_64
8030 | OPTI_TYPE_RAW_HASH;
8031 dgst_pos0 = 14;
8032 dgst_pos1 = 15;
8033 dgst_pos2 = 6;
8034 dgst_pos3 = 7;
8035 break;
8036
8037 case 1722: hash_type = HASH_TYPE_SHA512;
8038 salt_type = SALT_TYPE_EMBEDDED;
8039 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8040 opts_type = OPTS_TYPE_PT_GENERATE_BE
8041 | OPTS_TYPE_PT_ADD80
8042 | OPTS_TYPE_PT_ADDBITS15
8043 | OPTS_TYPE_ST_HEX;
8044 kern_type = KERN_TYPE_SHA512_SLTPW;
8045 dgst_size = DGST_SIZE_8_8;
8046 parse_func = osx512_parse_hash;
8047 sort_by_digest = sort_by_digest_8_8;
8048 opti_type = OPTI_TYPE_ZERO_BYTE
8049 | OPTI_TYPE_PRECOMPUTE_INIT
8050 | OPTI_TYPE_PRECOMPUTE_MERKLE
8051 | OPTI_TYPE_EARLY_SKIP
8052 | OPTI_TYPE_NOT_ITERATED
8053 | OPTI_TYPE_PREPENDED_SALT
8054 | OPTI_TYPE_USES_BITS_64
8055 | OPTI_TYPE_RAW_HASH;
8056 dgst_pos0 = 14;
8057 dgst_pos1 = 15;
8058 dgst_pos2 = 6;
8059 dgst_pos3 = 7;
8060 break;
8061
8062 case 1730: hash_type = HASH_TYPE_SHA512;
8063 salt_type = SALT_TYPE_INTERN;
8064 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8065 opts_type = OPTS_TYPE_PT_GENERATE_BE
8066 | OPTS_TYPE_PT_UNICODE
8067 | OPTS_TYPE_ST_ADD80
8068 | OPTS_TYPE_ST_ADDBITS15;
8069 kern_type = KERN_TYPE_SHA512_PWSLTU;
8070 dgst_size = DGST_SIZE_8_8;
8071 parse_func = sha512s_parse_hash;
8072 sort_by_digest = sort_by_digest_8_8;
8073 opti_type = OPTI_TYPE_ZERO_BYTE
8074 | OPTI_TYPE_PRECOMPUTE_INIT
8075 | OPTI_TYPE_PRECOMPUTE_MERKLE
8076 | OPTI_TYPE_EARLY_SKIP
8077 | OPTI_TYPE_NOT_ITERATED
8078 | OPTI_TYPE_APPENDED_SALT
8079 | OPTI_TYPE_USES_BITS_64
8080 | OPTI_TYPE_RAW_HASH;
8081 dgst_pos0 = 14;
8082 dgst_pos1 = 15;
8083 dgst_pos2 = 6;
8084 dgst_pos3 = 7;
8085 break;
8086
8087 case 1731: hash_type = HASH_TYPE_SHA512;
8088 salt_type = SALT_TYPE_EMBEDDED;
8089 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8090 opts_type = OPTS_TYPE_PT_GENERATE_BE
8091 | OPTS_TYPE_PT_UNICODE
8092 | OPTS_TYPE_ST_ADD80
8093 | OPTS_TYPE_ST_ADDBITS15
8094 | OPTS_TYPE_ST_HEX;
8095 kern_type = KERN_TYPE_SHA512_PWSLTU;
8096 dgst_size = DGST_SIZE_8_8;
8097 parse_func = mssql2012_parse_hash;
8098 sort_by_digest = sort_by_digest_8_8;
8099 opti_type = OPTI_TYPE_ZERO_BYTE
8100 | OPTI_TYPE_PRECOMPUTE_INIT
8101 | OPTI_TYPE_PRECOMPUTE_MERKLE
8102 | OPTI_TYPE_EARLY_SKIP
8103 | OPTI_TYPE_NOT_ITERATED
8104 | OPTI_TYPE_APPENDED_SALT
8105 | OPTI_TYPE_USES_BITS_64
8106 | OPTI_TYPE_RAW_HASH;
8107 dgst_pos0 = 14;
8108 dgst_pos1 = 15;
8109 dgst_pos2 = 6;
8110 dgst_pos3 = 7;
8111 break;
8112
8113 case 1740: hash_type = HASH_TYPE_SHA512;
8114 salt_type = SALT_TYPE_INTERN;
8115 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8116 opts_type = OPTS_TYPE_PT_GENERATE_BE
8117 | OPTS_TYPE_PT_ADD80
8118 | OPTS_TYPE_PT_ADDBITS15
8119 | OPTS_TYPE_PT_UNICODE;
8120 kern_type = KERN_TYPE_SHA512_SLTPWU;
8121 dgst_size = DGST_SIZE_8_8;
8122 parse_func = sha512s_parse_hash;
8123 sort_by_digest = sort_by_digest_8_8;
8124 opti_type = OPTI_TYPE_ZERO_BYTE
8125 | OPTI_TYPE_PRECOMPUTE_INIT
8126 | OPTI_TYPE_PRECOMPUTE_MERKLE
8127 | OPTI_TYPE_EARLY_SKIP
8128 | OPTI_TYPE_NOT_ITERATED
8129 | OPTI_TYPE_PREPENDED_SALT
8130 | OPTI_TYPE_USES_BITS_64
8131 | OPTI_TYPE_RAW_HASH;
8132 dgst_pos0 = 14;
8133 dgst_pos1 = 15;
8134 dgst_pos2 = 6;
8135 dgst_pos3 = 7;
8136 break;
8137
8138 case 1750: hash_type = HASH_TYPE_SHA512;
8139 salt_type = SALT_TYPE_INTERN;
8140 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8141 opts_type = OPTS_TYPE_PT_GENERATE_BE
8142 | OPTS_TYPE_ST_ADD80;
8143 kern_type = KERN_TYPE_HMACSHA512_PW;
8144 dgst_size = DGST_SIZE_8_8;
8145 parse_func = hmacsha512_parse_hash;
8146 sort_by_digest = sort_by_digest_8_8;
8147 opti_type = OPTI_TYPE_ZERO_BYTE
8148 | OPTI_TYPE_USES_BITS_64
8149 | OPTI_TYPE_NOT_ITERATED;
8150 dgst_pos0 = 14;
8151 dgst_pos1 = 15;
8152 dgst_pos2 = 6;
8153 dgst_pos3 = 7;
8154 break;
8155
8156 case 1760: hash_type = HASH_TYPE_SHA512;
8157 salt_type = SALT_TYPE_INTERN;
8158 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8159 opts_type = OPTS_TYPE_PT_GENERATE_BE
8160 | OPTS_TYPE_PT_ADD80
8161 | OPTS_TYPE_PT_ADDBITS15;
8162 kern_type = KERN_TYPE_HMACSHA512_SLT;
8163 dgst_size = DGST_SIZE_8_8;
8164 parse_func = hmacsha512_parse_hash;
8165 sort_by_digest = sort_by_digest_8_8;
8166 opti_type = OPTI_TYPE_ZERO_BYTE
8167 | OPTI_TYPE_USES_BITS_64
8168 | OPTI_TYPE_NOT_ITERATED;
8169 dgst_pos0 = 14;
8170 dgst_pos1 = 15;
8171 dgst_pos2 = 6;
8172 dgst_pos3 = 7;
8173 break;
8174
8175 case 1800: hash_type = HASH_TYPE_SHA512;
8176 salt_type = SALT_TYPE_EMBEDDED;
8177 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8178 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8179 kern_type = KERN_TYPE_SHA512CRYPT;
8180 dgst_size = DGST_SIZE_8_8;
8181 parse_func = sha512crypt_parse_hash;
8182 sort_by_digest = sort_by_digest_8_8;
8183 opti_type = OPTI_TYPE_ZERO_BYTE
8184 | OPTI_TYPE_USES_BITS_64;
8185 dgst_pos0 = 0;
8186 dgst_pos1 = 1;
8187 dgst_pos2 = 2;
8188 dgst_pos3 = 3;
8189 break;
8190
8191 case 2100: hash_type = HASH_TYPE_DCC2;
8192 salt_type = SALT_TYPE_EMBEDDED;
8193 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8194 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8195 | OPTS_TYPE_ST_LOWER
8196 | OPTS_TYPE_ST_UNICODE;
8197 kern_type = KERN_TYPE_DCC2;
8198 dgst_size = DGST_SIZE_4_4;
8199 parse_func = dcc2_parse_hash;
8200 sort_by_digest = sort_by_digest_4_4;
8201 opti_type = OPTI_TYPE_ZERO_BYTE;
8202 dgst_pos0 = 0;
8203 dgst_pos1 = 1;
8204 dgst_pos2 = 2;
8205 dgst_pos3 = 3;
8206 break;
8207
8208 case 2400: hash_type = HASH_TYPE_MD5;
8209 salt_type = SALT_TYPE_NONE;
8210 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8211 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8212 kern_type = KERN_TYPE_MD5PIX;
8213 dgst_size = DGST_SIZE_4_4;
8214 parse_func = md5pix_parse_hash;
8215 sort_by_digest = sort_by_digest_4_4;
8216 opti_type = OPTI_TYPE_ZERO_BYTE
8217 | OPTI_TYPE_PRECOMPUTE_INIT
8218 | OPTI_TYPE_PRECOMPUTE_MERKLE
8219 | OPTI_TYPE_EARLY_SKIP
8220 | OPTI_TYPE_NOT_ITERATED
8221 | OPTI_TYPE_NOT_SALTED;
8222 dgst_pos0 = 0;
8223 dgst_pos1 = 3;
8224 dgst_pos2 = 2;
8225 dgst_pos3 = 1;
8226 break;
8227
8228 case 2410: hash_type = HASH_TYPE_MD5;
8229 salt_type = SALT_TYPE_INTERN;
8230 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8231 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8232 kern_type = KERN_TYPE_MD5ASA;
8233 dgst_size = DGST_SIZE_4_4;
8234 parse_func = md5asa_parse_hash;
8235 sort_by_digest = sort_by_digest_4_4;
8236 opti_type = OPTI_TYPE_ZERO_BYTE
8237 | OPTI_TYPE_PRECOMPUTE_INIT
8238 | OPTI_TYPE_PRECOMPUTE_MERKLE
8239 | OPTI_TYPE_EARLY_SKIP
8240 | OPTI_TYPE_NOT_ITERATED;
8241 dgst_pos0 = 0;
8242 dgst_pos1 = 3;
8243 dgst_pos2 = 2;
8244 dgst_pos3 = 1;
8245 break;
8246
8247 case 2500: hash_type = HASH_TYPE_WPA;
8248 salt_type = SALT_TYPE_EMBEDDED;
8249 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8250 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8251 kern_type = KERN_TYPE_WPA;
8252 dgst_size = DGST_SIZE_4_4;
8253 parse_func = wpa_parse_hash;
8254 sort_by_digest = sort_by_digest_4_4;
8255 opti_type = OPTI_TYPE_ZERO_BYTE;
8256 dgst_pos0 = 0;
8257 dgst_pos1 = 1;
8258 dgst_pos2 = 2;
8259 dgst_pos3 = 3;
8260 break;
8261
8262 case 2600: hash_type = HASH_TYPE_MD5;
8263 salt_type = SALT_TYPE_VIRTUAL;
8264 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8265 opts_type = OPTS_TYPE_PT_GENERATE_LE
8266 | OPTS_TYPE_PT_ADD80
8267 | OPTS_TYPE_PT_ADDBITS14
8268 | OPTS_TYPE_ST_ADD80;
8269 kern_type = KERN_TYPE_MD55_PWSLT1;
8270 dgst_size = DGST_SIZE_4_4;
8271 parse_func = md5md5_parse_hash;
8272 sort_by_digest = sort_by_digest_4_4;
8273 opti_type = OPTI_TYPE_ZERO_BYTE
8274 | OPTI_TYPE_PRECOMPUTE_INIT
8275 | OPTI_TYPE_PRECOMPUTE_MERKLE
8276 | OPTI_TYPE_EARLY_SKIP;
8277 dgst_pos0 = 0;
8278 dgst_pos1 = 3;
8279 dgst_pos2 = 2;
8280 dgst_pos3 = 1;
8281 break;
8282
8283 case 2611: hash_type = HASH_TYPE_MD5;
8284 salt_type = SALT_TYPE_INTERN;
8285 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8286 opts_type = OPTS_TYPE_PT_GENERATE_LE
8287 | OPTS_TYPE_PT_ADD80
8288 | OPTS_TYPE_PT_ADDBITS14
8289 | OPTS_TYPE_ST_ADD80;
8290 kern_type = KERN_TYPE_MD55_PWSLT1;
8291 dgst_size = DGST_SIZE_4_4;
8292 parse_func = vb3_parse_hash;
8293 sort_by_digest = sort_by_digest_4_4;
8294 opti_type = OPTI_TYPE_ZERO_BYTE
8295 | OPTI_TYPE_PRECOMPUTE_INIT
8296 | OPTI_TYPE_PRECOMPUTE_MERKLE
8297 | OPTI_TYPE_EARLY_SKIP;
8298 dgst_pos0 = 0;
8299 dgst_pos1 = 3;
8300 dgst_pos2 = 2;
8301 dgst_pos3 = 1;
8302 break;
8303
8304 case 2612: hash_type = HASH_TYPE_MD5;
8305 salt_type = SALT_TYPE_EMBEDDED;
8306 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8307 opts_type = OPTS_TYPE_PT_GENERATE_LE
8308 | OPTS_TYPE_PT_ADD80
8309 | OPTS_TYPE_PT_ADDBITS14
8310 | OPTS_TYPE_ST_ADD80
8311 | OPTS_TYPE_ST_HEX;
8312 kern_type = KERN_TYPE_MD55_PWSLT1;
8313 dgst_size = DGST_SIZE_4_4;
8314 parse_func = phps_parse_hash;
8315 sort_by_digest = sort_by_digest_4_4;
8316 opti_type = OPTI_TYPE_ZERO_BYTE
8317 | OPTI_TYPE_PRECOMPUTE_INIT
8318 | OPTI_TYPE_PRECOMPUTE_MERKLE
8319 | OPTI_TYPE_EARLY_SKIP;
8320 dgst_pos0 = 0;
8321 dgst_pos1 = 3;
8322 dgst_pos2 = 2;
8323 dgst_pos3 = 1;
8324 break;
8325
8326 case 2711: hash_type = HASH_TYPE_MD5;
8327 salt_type = SALT_TYPE_INTERN;
8328 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8329 opts_type = OPTS_TYPE_PT_GENERATE_LE
8330 | OPTS_TYPE_PT_ADD80
8331 | OPTS_TYPE_PT_ADDBITS14
8332 | OPTS_TYPE_ST_ADD80;
8333 kern_type = KERN_TYPE_MD55_PWSLT2;
8334 dgst_size = DGST_SIZE_4_4;
8335 parse_func = vb30_parse_hash;
8336 sort_by_digest = sort_by_digest_4_4;
8337 opti_type = OPTI_TYPE_ZERO_BYTE
8338 | OPTI_TYPE_PRECOMPUTE_INIT
8339 | OPTI_TYPE_EARLY_SKIP;
8340 dgst_pos0 = 0;
8341 dgst_pos1 = 3;
8342 dgst_pos2 = 2;
8343 dgst_pos3 = 1;
8344 break;
8345
8346 case 2811: hash_type = HASH_TYPE_MD5;
8347 salt_type = SALT_TYPE_INTERN;
8348 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8349 opts_type = OPTS_TYPE_PT_GENERATE_LE
8350 | OPTS_TYPE_PT_ADD80
8351 | OPTS_TYPE_PT_ADDBITS14;
8352 kern_type = KERN_TYPE_MD55_SLTPW;
8353 dgst_size = DGST_SIZE_4_4;
8354 parse_func = ipb2_parse_hash;
8355 sort_by_digest = sort_by_digest_4_4;
8356 opti_type = OPTI_TYPE_ZERO_BYTE
8357 | OPTI_TYPE_PRECOMPUTE_INIT
8358 | OPTI_TYPE_EARLY_SKIP;
8359 dgst_pos0 = 0;
8360 dgst_pos1 = 3;
8361 dgst_pos2 = 2;
8362 dgst_pos3 = 1;
8363 break;
8364
8365 case 3000: hash_type = HASH_TYPE_LM;
8366 salt_type = SALT_TYPE_NONE;
8367 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8368 opts_type = OPTS_TYPE_PT_GENERATE_LE
8369 | OPTS_TYPE_PT_UPPER
8370 | OPTS_TYPE_PT_BITSLICE;
8371 kern_type = KERN_TYPE_LM;
8372 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8373 parse_func = lm_parse_hash;
8374 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8375 opti_type = OPTI_TYPE_ZERO_BYTE
8376 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8377 dgst_pos0 = 0;
8378 dgst_pos1 = 1;
8379 dgst_pos2 = 2;
8380 dgst_pos3 = 3;
8381 break;
8382
8383 case 3100: hash_type = HASH_TYPE_ORACLEH;
8384 salt_type = SALT_TYPE_INTERN;
8385 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8386 opts_type = OPTS_TYPE_PT_GENERATE_LE
8387 | OPTS_TYPE_PT_UPPER
8388 | OPTS_TYPE_ST_UPPER;
8389 kern_type = KERN_TYPE_ORACLEH;
8390 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8391 parse_func = oracleh_parse_hash;
8392 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8393 opti_type = OPTI_TYPE_ZERO_BYTE;
8394 dgst_pos0 = 0;
8395 dgst_pos1 = 1;
8396 dgst_pos2 = 2;
8397 dgst_pos3 = 3;
8398 break;
8399
8400 case 3200: hash_type = HASH_TYPE_BCRYPT;
8401 salt_type = SALT_TYPE_EMBEDDED;
8402 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8403 opts_type = OPTS_TYPE_PT_GENERATE_LE
8404 | OPTS_TYPE_ST_GENERATE_LE;
8405 kern_type = KERN_TYPE_BCRYPT;
8406 dgst_size = DGST_SIZE_4_6;
8407 parse_func = bcrypt_parse_hash;
8408 sort_by_digest = sort_by_digest_4_6;
8409 opti_type = OPTI_TYPE_ZERO_BYTE;
8410 dgst_pos0 = 0;
8411 dgst_pos1 = 1;
8412 dgst_pos2 = 2;
8413 dgst_pos3 = 3;
8414 break;
8415
8416 case 3710: hash_type = HASH_TYPE_MD5;
8417 salt_type = SALT_TYPE_INTERN;
8418 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8419 opts_type = OPTS_TYPE_PT_GENERATE_LE
8420 | OPTS_TYPE_PT_ADD80
8421 | OPTS_TYPE_PT_ADDBITS14;
8422 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8423 dgst_size = DGST_SIZE_4_4;
8424 parse_func = md5s_parse_hash;
8425 sort_by_digest = sort_by_digest_4_4;
8426 opti_type = OPTI_TYPE_ZERO_BYTE
8427 | OPTI_TYPE_PRECOMPUTE_INIT
8428 | OPTI_TYPE_PRECOMPUTE_MERKLE
8429 | OPTI_TYPE_EARLY_SKIP;
8430 dgst_pos0 = 0;
8431 dgst_pos1 = 3;
8432 dgst_pos2 = 2;
8433 dgst_pos3 = 1;
8434 break;
8435
8436 case 3711: hash_type = HASH_TYPE_MD5;
8437 salt_type = SALT_TYPE_EMBEDDED;
8438 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8439 opts_type = OPTS_TYPE_PT_GENERATE_LE
8440 | OPTS_TYPE_PT_ADD80
8441 | OPTS_TYPE_PT_ADDBITS14;
8442 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8443 dgst_size = DGST_SIZE_4_4;
8444 parse_func = mediawiki_b_parse_hash;
8445 sort_by_digest = sort_by_digest_4_4;
8446 opti_type = OPTI_TYPE_ZERO_BYTE
8447 | OPTI_TYPE_PRECOMPUTE_INIT
8448 | OPTI_TYPE_PRECOMPUTE_MERKLE
8449 | OPTI_TYPE_EARLY_SKIP;
8450 dgst_pos0 = 0;
8451 dgst_pos1 = 3;
8452 dgst_pos2 = 2;
8453 dgst_pos3 = 1;
8454 break;
8455
8456 case 3800: hash_type = HASH_TYPE_MD5;
8457 salt_type = SALT_TYPE_INTERN;
8458 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8459 opts_type = OPTS_TYPE_PT_GENERATE_LE
8460 | OPTS_TYPE_ST_ADDBITS14;
8461 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8462 dgst_size = DGST_SIZE_4_4;
8463 parse_func = md5s_parse_hash;
8464 sort_by_digest = sort_by_digest_4_4;
8465 opti_type = OPTI_TYPE_ZERO_BYTE
8466 | OPTI_TYPE_PRECOMPUTE_INIT
8467 | OPTI_TYPE_PRECOMPUTE_MERKLE
8468 | OPTI_TYPE_EARLY_SKIP
8469 | OPTI_TYPE_NOT_ITERATED
8470 | OPTI_TYPE_RAW_HASH;
8471 dgst_pos0 = 0;
8472 dgst_pos1 = 3;
8473 dgst_pos2 = 2;
8474 dgst_pos3 = 1;
8475 break;
8476
8477 case 4300: hash_type = HASH_TYPE_MD5;
8478 salt_type = SALT_TYPE_VIRTUAL;
8479 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8480 opts_type = OPTS_TYPE_PT_GENERATE_LE
8481 | OPTS_TYPE_PT_ADD80
8482 | OPTS_TYPE_PT_ADDBITS14
8483 | OPTS_TYPE_ST_ADD80;
8484 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8485 dgst_size = DGST_SIZE_4_4;
8486 parse_func = md5md5_parse_hash;
8487 sort_by_digest = sort_by_digest_4_4;
8488 opti_type = OPTI_TYPE_ZERO_BYTE
8489 | OPTI_TYPE_PRECOMPUTE_INIT
8490 | OPTI_TYPE_PRECOMPUTE_MERKLE
8491 | OPTI_TYPE_EARLY_SKIP;
8492 dgst_pos0 = 0;
8493 dgst_pos1 = 3;
8494 dgst_pos2 = 2;
8495 dgst_pos3 = 1;
8496 break;
8497
8498
8499 case 4400: hash_type = HASH_TYPE_MD5;
8500 salt_type = SALT_TYPE_NONE;
8501 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8502 opts_type = OPTS_TYPE_PT_GENERATE_BE
8503 | OPTS_TYPE_PT_ADD80
8504 | OPTS_TYPE_PT_ADDBITS15;
8505 kern_type = KERN_TYPE_MD5_SHA1;
8506 dgst_size = DGST_SIZE_4_4;
8507 parse_func = md5_parse_hash;
8508 sort_by_digest = sort_by_digest_4_4;
8509 opti_type = OPTI_TYPE_ZERO_BYTE
8510 | OPTI_TYPE_PRECOMPUTE_INIT
8511 | OPTI_TYPE_PRECOMPUTE_MERKLE
8512 | OPTI_TYPE_EARLY_SKIP
8513 | OPTI_TYPE_NOT_ITERATED
8514 | OPTI_TYPE_NOT_SALTED
8515 | OPTI_TYPE_RAW_HASH;
8516 dgst_pos0 = 0;
8517 dgst_pos1 = 3;
8518 dgst_pos2 = 2;
8519 dgst_pos3 = 1;
8520 break;
8521
8522 case 4500: hash_type = HASH_TYPE_SHA1;
8523 salt_type = SALT_TYPE_NONE;
8524 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8525 opts_type = OPTS_TYPE_PT_GENERATE_BE
8526 | OPTS_TYPE_PT_ADD80
8527 | OPTS_TYPE_PT_ADDBITS15;
8528 kern_type = KERN_TYPE_SHA11;
8529 dgst_size = DGST_SIZE_4_5;
8530 parse_func = sha1_parse_hash;
8531 sort_by_digest = sort_by_digest_4_5;
8532 opti_type = OPTI_TYPE_ZERO_BYTE
8533 | OPTI_TYPE_PRECOMPUTE_INIT
8534 | OPTI_TYPE_PRECOMPUTE_MERKLE
8535 | OPTI_TYPE_EARLY_SKIP
8536 | OPTI_TYPE_NOT_SALTED;
8537 dgst_pos0 = 3;
8538 dgst_pos1 = 4;
8539 dgst_pos2 = 2;
8540 dgst_pos3 = 1;
8541 break;
8542
8543 case 4700: hash_type = HASH_TYPE_SHA1;
8544 salt_type = SALT_TYPE_NONE;
8545 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8546 opts_type = OPTS_TYPE_PT_GENERATE_LE
8547 | OPTS_TYPE_PT_ADD80
8548 | OPTS_TYPE_PT_ADDBITS14;
8549 kern_type = KERN_TYPE_SHA1_MD5;
8550 dgst_size = DGST_SIZE_4_5;
8551 parse_func = sha1_parse_hash;
8552 sort_by_digest = sort_by_digest_4_5;
8553 opti_type = OPTI_TYPE_ZERO_BYTE
8554 | OPTI_TYPE_PRECOMPUTE_INIT
8555 | OPTI_TYPE_PRECOMPUTE_MERKLE
8556 | OPTI_TYPE_EARLY_SKIP
8557 | OPTI_TYPE_NOT_ITERATED
8558 | OPTI_TYPE_NOT_SALTED
8559 | OPTI_TYPE_RAW_HASH;
8560 dgst_pos0 = 3;
8561 dgst_pos1 = 4;
8562 dgst_pos2 = 2;
8563 dgst_pos3 = 1;
8564 break;
8565
8566 case 4800: hash_type = HASH_TYPE_MD5;
8567 salt_type = SALT_TYPE_EMBEDDED;
8568 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8569 opts_type = OPTS_TYPE_PT_GENERATE_LE
8570 | OPTS_TYPE_PT_ADDBITS14;
8571 kern_type = KERN_TYPE_MD5_CHAP;
8572 dgst_size = DGST_SIZE_4_4;
8573 parse_func = chap_parse_hash;
8574 sort_by_digest = sort_by_digest_4_4;
8575 opti_type = OPTI_TYPE_ZERO_BYTE
8576 | OPTI_TYPE_PRECOMPUTE_INIT
8577 | OPTI_TYPE_PRECOMPUTE_MERKLE
8578 | OPTI_TYPE_MEET_IN_MIDDLE
8579 | OPTI_TYPE_EARLY_SKIP
8580 | OPTI_TYPE_NOT_ITERATED
8581 | OPTI_TYPE_RAW_HASH;
8582 dgst_pos0 = 0;
8583 dgst_pos1 = 3;
8584 dgst_pos2 = 2;
8585 dgst_pos3 = 1;
8586 break;
8587
8588 case 4900: hash_type = HASH_TYPE_SHA1;
8589 salt_type = SALT_TYPE_INTERN;
8590 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8591 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8592 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8593 dgst_size = DGST_SIZE_4_5;
8594 parse_func = sha1s_parse_hash;
8595 sort_by_digest = sort_by_digest_4_5;
8596 opti_type = OPTI_TYPE_ZERO_BYTE
8597 | OPTI_TYPE_PRECOMPUTE_INIT
8598 | OPTI_TYPE_PRECOMPUTE_MERKLE
8599 | OPTI_TYPE_EARLY_SKIP;
8600 dgst_pos0 = 3;
8601 dgst_pos1 = 4;
8602 dgst_pos2 = 2;
8603 dgst_pos3 = 1;
8604 break;
8605
8606 case 5000: hash_type = HASH_TYPE_KECCAK;
8607 salt_type = SALT_TYPE_EMBEDDED;
8608 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8609 opts_type = OPTS_TYPE_PT_GENERATE_LE
8610 | OPTS_TYPE_PT_ADD01;
8611 kern_type = KERN_TYPE_KECCAK;
8612 dgst_size = DGST_SIZE_8_25;
8613 parse_func = keccak_parse_hash;
8614 sort_by_digest = sort_by_digest_8_25;
8615 opti_type = OPTI_TYPE_ZERO_BYTE
8616 | OPTI_TYPE_USES_BITS_64
8617 | OPTI_TYPE_RAW_HASH;
8618 dgst_pos0 = 2;
8619 dgst_pos1 = 3;
8620 dgst_pos2 = 4;
8621 dgst_pos3 = 5;
8622 break;
8623
8624 case 5100: hash_type = HASH_TYPE_MD5H;
8625 salt_type = SALT_TYPE_NONE;
8626 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8627 opts_type = OPTS_TYPE_PT_GENERATE_LE
8628 | OPTS_TYPE_PT_ADD80
8629 | OPTS_TYPE_PT_ADDBITS14;
8630 kern_type = KERN_TYPE_MD5H;
8631 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8632 parse_func = md5half_parse_hash;
8633 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8634 opti_type = OPTI_TYPE_ZERO_BYTE
8635 | OPTI_TYPE_RAW_HASH;
8636 dgst_pos0 = 0;
8637 dgst_pos1 = 1;
8638 dgst_pos2 = 2;
8639 dgst_pos3 = 3;
8640 break;
8641
8642 case 5200: hash_type = HASH_TYPE_SHA256;
8643 salt_type = SALT_TYPE_EMBEDDED;
8644 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8645 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8646 kern_type = KERN_TYPE_PSAFE3;
8647 dgst_size = DGST_SIZE_4_8;
8648 parse_func = psafe3_parse_hash;
8649 sort_by_digest = sort_by_digest_4_8;
8650 opti_type = OPTI_TYPE_ZERO_BYTE;
8651 dgst_pos0 = 0;
8652 dgst_pos1 = 1;
8653 dgst_pos2 = 2;
8654 dgst_pos3 = 3;
8655 break;
8656
8657 case 5300: hash_type = HASH_TYPE_MD5;
8658 salt_type = SALT_TYPE_EMBEDDED;
8659 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8660 opts_type = OPTS_TYPE_PT_GENERATE_LE
8661 | OPTS_TYPE_ST_ADD80;
8662 kern_type = KERN_TYPE_IKEPSK_MD5;
8663 dgst_size = DGST_SIZE_4_4;
8664 parse_func = ikepsk_md5_parse_hash;
8665 sort_by_digest = sort_by_digest_4_4;
8666 opti_type = OPTI_TYPE_ZERO_BYTE;
8667 dgst_pos0 = 0;
8668 dgst_pos1 = 3;
8669 dgst_pos2 = 2;
8670 dgst_pos3 = 1;
8671 break;
8672
8673 case 5400: hash_type = HASH_TYPE_SHA1;
8674 salt_type = SALT_TYPE_EMBEDDED;
8675 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8676 opts_type = OPTS_TYPE_PT_GENERATE_BE
8677 | OPTS_TYPE_ST_ADD80;
8678 kern_type = KERN_TYPE_IKEPSK_SHA1;
8679 dgst_size = DGST_SIZE_4_5;
8680 parse_func = ikepsk_sha1_parse_hash;
8681 sort_by_digest = sort_by_digest_4_5;
8682 opti_type = OPTI_TYPE_ZERO_BYTE;
8683 dgst_pos0 = 3;
8684 dgst_pos1 = 4;
8685 dgst_pos2 = 2;
8686 dgst_pos3 = 1;
8687 break;
8688
8689 case 5500: hash_type = HASH_TYPE_NETNTLM;
8690 salt_type = SALT_TYPE_EMBEDDED;
8691 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8692 opts_type = OPTS_TYPE_PT_GENERATE_LE
8693 | OPTS_TYPE_PT_ADD80
8694 | OPTS_TYPE_PT_ADDBITS14
8695 | OPTS_TYPE_PT_UNICODE
8696 | OPTS_TYPE_ST_HEX;
8697 kern_type = KERN_TYPE_NETNTLMv1;
8698 dgst_size = DGST_SIZE_4_4;
8699 parse_func = netntlmv1_parse_hash;
8700 sort_by_digest = sort_by_digest_4_4;
8701 opti_type = OPTI_TYPE_ZERO_BYTE
8702 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8703 dgst_pos0 = 0;
8704 dgst_pos1 = 1;
8705 dgst_pos2 = 2;
8706 dgst_pos3 = 3;
8707 break;
8708
8709 case 5600: hash_type = HASH_TYPE_MD5;
8710 salt_type = SALT_TYPE_EMBEDDED;
8711 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8712 opts_type = OPTS_TYPE_PT_GENERATE_LE
8713 | OPTS_TYPE_PT_ADD80
8714 | OPTS_TYPE_PT_ADDBITS14
8715 | OPTS_TYPE_PT_UNICODE;
8716 kern_type = KERN_TYPE_NETNTLMv2;
8717 dgst_size = DGST_SIZE_4_4;
8718 parse_func = netntlmv2_parse_hash;
8719 sort_by_digest = sort_by_digest_4_4;
8720 opti_type = OPTI_TYPE_ZERO_BYTE;
8721 dgst_pos0 = 0;
8722 dgst_pos1 = 3;
8723 dgst_pos2 = 2;
8724 dgst_pos3 = 1;
8725 break;
8726
8727 case 5700: hash_type = HASH_TYPE_SHA256;
8728 salt_type = SALT_TYPE_NONE;
8729 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8730 opts_type = OPTS_TYPE_PT_GENERATE_BE
8731 | OPTS_TYPE_PT_ADD80
8732 | OPTS_TYPE_PT_ADDBITS15;
8733 kern_type = KERN_TYPE_SHA256;
8734 dgst_size = DGST_SIZE_4_8;
8735 parse_func = cisco4_parse_hash;
8736 sort_by_digest = sort_by_digest_4_8;
8737 opti_type = OPTI_TYPE_ZERO_BYTE
8738 | OPTI_TYPE_PRECOMPUTE_INIT
8739 | OPTI_TYPE_PRECOMPUTE_MERKLE
8740 | OPTI_TYPE_EARLY_SKIP
8741 | OPTI_TYPE_NOT_ITERATED
8742 | OPTI_TYPE_NOT_SALTED
8743 | OPTI_TYPE_RAW_HASH;
8744 dgst_pos0 = 3;
8745 dgst_pos1 = 7;
8746 dgst_pos2 = 2;
8747 dgst_pos3 = 6;
8748 break;
8749
8750 case 5800: hash_type = HASH_TYPE_SHA1;
8751 salt_type = SALT_TYPE_INTERN;
8752 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8753 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8754 | OPTS_TYPE_ST_ADD80;
8755 kern_type = KERN_TYPE_ANDROIDPIN;
8756 dgst_size = DGST_SIZE_4_5;
8757 parse_func = androidpin_parse_hash;
8758 sort_by_digest = sort_by_digest_4_5;
8759 opti_type = OPTI_TYPE_ZERO_BYTE;
8760 dgst_pos0 = 0;
8761 dgst_pos1 = 1;
8762 dgst_pos2 = 2;
8763 dgst_pos3 = 3;
8764 break;
8765
8766 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8767 salt_type = SALT_TYPE_NONE;
8768 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8769 opts_type = OPTS_TYPE_PT_GENERATE_LE
8770 | OPTS_TYPE_PT_ADD80;
8771 kern_type = KERN_TYPE_RIPEMD160;
8772 dgst_size = DGST_SIZE_4_5;
8773 parse_func = ripemd160_parse_hash;
8774 sort_by_digest = sort_by_digest_4_5;
8775 opti_type = OPTI_TYPE_ZERO_BYTE;
8776 dgst_pos0 = 0;
8777 dgst_pos1 = 1;
8778 dgst_pos2 = 2;
8779 dgst_pos3 = 3;
8780 break;
8781
8782 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8783 salt_type = SALT_TYPE_NONE;
8784 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8785 opts_type = OPTS_TYPE_PT_GENERATE_BE
8786 | OPTS_TYPE_PT_ADD80;
8787 kern_type = KERN_TYPE_WHIRLPOOL;
8788 dgst_size = DGST_SIZE_4_16;
8789 parse_func = whirlpool_parse_hash;
8790 sort_by_digest = sort_by_digest_4_16;
8791 opti_type = OPTI_TYPE_ZERO_BYTE;
8792 dgst_pos0 = 0;
8793 dgst_pos1 = 1;
8794 dgst_pos2 = 2;
8795 dgst_pos3 = 3;
8796 break;
8797
8798 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8799 salt_type = SALT_TYPE_EMBEDDED;
8800 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8801 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8802 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8803 dgst_size = DGST_SIZE_4_5;
8804 parse_func = truecrypt_parse_hash_2k;
8805 sort_by_digest = sort_by_digest_4_5;
8806 opti_type = OPTI_TYPE_ZERO_BYTE;
8807 dgst_pos0 = 0;
8808 dgst_pos1 = 1;
8809 dgst_pos2 = 2;
8810 dgst_pos3 = 3;
8811 break;
8812
8813 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8814 salt_type = SALT_TYPE_EMBEDDED;
8815 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8816 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8817 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8818 dgst_size = DGST_SIZE_4_5;
8819 parse_func = truecrypt_parse_hash_2k;
8820 sort_by_digest = sort_by_digest_4_5;
8821 opti_type = OPTI_TYPE_ZERO_BYTE;
8822 dgst_pos0 = 0;
8823 dgst_pos1 = 1;
8824 dgst_pos2 = 2;
8825 dgst_pos3 = 3;
8826 break;
8827
8828 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8829 salt_type = SALT_TYPE_EMBEDDED;
8830 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8831 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8832 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8833 dgst_size = DGST_SIZE_4_5;
8834 parse_func = truecrypt_parse_hash_2k;
8835 sort_by_digest = sort_by_digest_4_5;
8836 opti_type = OPTI_TYPE_ZERO_BYTE;
8837 dgst_pos0 = 0;
8838 dgst_pos1 = 1;
8839 dgst_pos2 = 2;
8840 dgst_pos3 = 3;
8841 break;
8842
8843 case 6221: hash_type = HASH_TYPE_SHA512;
8844 salt_type = SALT_TYPE_EMBEDDED;
8845 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8846 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8847 kern_type = KERN_TYPE_TCSHA512_XTS512;
8848 dgst_size = DGST_SIZE_8_8;
8849 parse_func = truecrypt_parse_hash_1k;
8850 sort_by_digest = sort_by_digest_8_8;
8851 opti_type = OPTI_TYPE_ZERO_BYTE
8852 | OPTI_TYPE_USES_BITS_64;
8853 dgst_pos0 = 0;
8854 dgst_pos1 = 1;
8855 dgst_pos2 = 2;
8856 dgst_pos3 = 3;
8857 break;
8858
8859 case 6222: hash_type = HASH_TYPE_SHA512;
8860 salt_type = SALT_TYPE_EMBEDDED;
8861 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8862 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8863 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8864 dgst_size = DGST_SIZE_8_8;
8865 parse_func = truecrypt_parse_hash_1k;
8866 sort_by_digest = sort_by_digest_8_8;
8867 opti_type = OPTI_TYPE_ZERO_BYTE
8868 | OPTI_TYPE_USES_BITS_64;
8869 dgst_pos0 = 0;
8870 dgst_pos1 = 1;
8871 dgst_pos2 = 2;
8872 dgst_pos3 = 3;
8873 break;
8874
8875 case 6223: hash_type = HASH_TYPE_SHA512;
8876 salt_type = SALT_TYPE_EMBEDDED;
8877 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8878 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8879 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8880 dgst_size = DGST_SIZE_8_8;
8881 parse_func = truecrypt_parse_hash_1k;
8882 sort_by_digest = sort_by_digest_8_8;
8883 opti_type = OPTI_TYPE_ZERO_BYTE
8884 | OPTI_TYPE_USES_BITS_64;
8885 dgst_pos0 = 0;
8886 dgst_pos1 = 1;
8887 dgst_pos2 = 2;
8888 dgst_pos3 = 3;
8889 break;
8890
8891 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8892 salt_type = SALT_TYPE_EMBEDDED;
8893 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8894 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8895 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8896 dgst_size = DGST_SIZE_4_8;
8897 parse_func = truecrypt_parse_hash_1k;
8898 sort_by_digest = sort_by_digest_4_8;
8899 opti_type = OPTI_TYPE_ZERO_BYTE;
8900 dgst_pos0 = 0;
8901 dgst_pos1 = 1;
8902 dgst_pos2 = 2;
8903 dgst_pos3 = 3;
8904 break;
8905
8906 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8907 salt_type = SALT_TYPE_EMBEDDED;
8908 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8909 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8910 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8911 dgst_size = DGST_SIZE_4_8;
8912 parse_func = truecrypt_parse_hash_1k;
8913 sort_by_digest = sort_by_digest_4_8;
8914 opti_type = OPTI_TYPE_ZERO_BYTE;
8915 dgst_pos0 = 0;
8916 dgst_pos1 = 1;
8917 dgst_pos2 = 2;
8918 dgst_pos3 = 3;
8919 break;
8920
8921 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8922 salt_type = SALT_TYPE_EMBEDDED;
8923 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8924 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8925 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8926 dgst_size = DGST_SIZE_4_8;
8927 parse_func = truecrypt_parse_hash_1k;
8928 sort_by_digest = sort_by_digest_4_8;
8929 opti_type = OPTI_TYPE_ZERO_BYTE;
8930 dgst_pos0 = 0;
8931 dgst_pos1 = 1;
8932 dgst_pos2 = 2;
8933 dgst_pos3 = 3;
8934 break;
8935
8936 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8937 salt_type = SALT_TYPE_EMBEDDED;
8938 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8939 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8940 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8941 dgst_size = DGST_SIZE_4_5;
8942 parse_func = truecrypt_parse_hash_1k;
8943 sort_by_digest = sort_by_digest_4_5;
8944 opti_type = OPTI_TYPE_ZERO_BYTE;
8945 dgst_pos0 = 0;
8946 dgst_pos1 = 1;
8947 dgst_pos2 = 2;
8948 dgst_pos3 = 3;
8949 break;
8950
8951 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8952 salt_type = SALT_TYPE_EMBEDDED;
8953 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8954 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8955 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8956 dgst_size = DGST_SIZE_4_5;
8957 parse_func = truecrypt_parse_hash_1k;
8958 sort_by_digest = sort_by_digest_4_5;
8959 opti_type = OPTI_TYPE_ZERO_BYTE;
8960 dgst_pos0 = 0;
8961 dgst_pos1 = 1;
8962 dgst_pos2 = 2;
8963 dgst_pos3 = 3;
8964 break;
8965
8966 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8967 salt_type = SALT_TYPE_EMBEDDED;
8968 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8969 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8970 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8971 dgst_size = DGST_SIZE_4_5;
8972 parse_func = truecrypt_parse_hash_1k;
8973 sort_by_digest = sort_by_digest_4_5;
8974 opti_type = OPTI_TYPE_ZERO_BYTE;
8975 dgst_pos0 = 0;
8976 dgst_pos1 = 1;
8977 dgst_pos2 = 2;
8978 dgst_pos3 = 3;
8979 break;
8980
8981 case 6300: hash_type = HASH_TYPE_MD5;
8982 salt_type = SALT_TYPE_EMBEDDED;
8983 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8984 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8985 kern_type = KERN_TYPE_MD5AIX;
8986 dgst_size = DGST_SIZE_4_4;
8987 parse_func = md5aix_parse_hash;
8988 sort_by_digest = sort_by_digest_4_4;
8989 opti_type = OPTI_TYPE_ZERO_BYTE;
8990 dgst_pos0 = 0;
8991 dgst_pos1 = 1;
8992 dgst_pos2 = 2;
8993 dgst_pos3 = 3;
8994 break;
8995
8996 case 6400: hash_type = HASH_TYPE_SHA256;
8997 salt_type = SALT_TYPE_EMBEDDED;
8998 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8999 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9000 kern_type = KERN_TYPE_SHA256AIX;
9001 dgst_size = DGST_SIZE_4_8;
9002 parse_func = sha256aix_parse_hash;
9003 sort_by_digest = sort_by_digest_4_8;
9004 opti_type = OPTI_TYPE_ZERO_BYTE;
9005 dgst_pos0 = 0;
9006 dgst_pos1 = 1;
9007 dgst_pos2 = 2;
9008 dgst_pos3 = 3;
9009 break;
9010
9011 case 6500: hash_type = HASH_TYPE_SHA512;
9012 salt_type = SALT_TYPE_EMBEDDED;
9013 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9014 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9015 kern_type = KERN_TYPE_SHA512AIX;
9016 dgst_size = DGST_SIZE_8_8;
9017 parse_func = sha512aix_parse_hash;
9018 sort_by_digest = sort_by_digest_8_8;
9019 opti_type = OPTI_TYPE_ZERO_BYTE
9020 | OPTI_TYPE_USES_BITS_64;
9021 dgst_pos0 = 0;
9022 dgst_pos1 = 1;
9023 dgst_pos2 = 2;
9024 dgst_pos3 = 3;
9025 break;
9026
9027 case 6600: hash_type = HASH_TYPE_AES;
9028 salt_type = SALT_TYPE_EMBEDDED;
9029 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9030 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9031 kern_type = KERN_TYPE_AGILEKEY;
9032 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9033 parse_func = agilekey_parse_hash;
9034 sort_by_digest = sort_by_digest_4_5;
9035 opti_type = OPTI_TYPE_ZERO_BYTE;
9036 dgst_pos0 = 0;
9037 dgst_pos1 = 1;
9038 dgst_pos2 = 2;
9039 dgst_pos3 = 3;
9040 break;
9041
9042 case 6700: hash_type = HASH_TYPE_SHA1;
9043 salt_type = SALT_TYPE_EMBEDDED;
9044 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9045 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9046 kern_type = KERN_TYPE_SHA1AIX;
9047 dgst_size = DGST_SIZE_4_5;
9048 parse_func = sha1aix_parse_hash;
9049 sort_by_digest = sort_by_digest_4_5;
9050 opti_type = OPTI_TYPE_ZERO_BYTE;
9051 dgst_pos0 = 0;
9052 dgst_pos1 = 1;
9053 dgst_pos2 = 2;
9054 dgst_pos3 = 3;
9055 break;
9056
9057 case 6800: hash_type = HASH_TYPE_AES;
9058 salt_type = SALT_TYPE_EMBEDDED;
9059 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9060 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9061 kern_type = KERN_TYPE_LASTPASS;
9062 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9063 parse_func = lastpass_parse_hash;
9064 sort_by_digest = sort_by_digest_4_8;
9065 opti_type = OPTI_TYPE_ZERO_BYTE;
9066 dgst_pos0 = 0;
9067 dgst_pos1 = 1;
9068 dgst_pos2 = 2;
9069 dgst_pos3 = 3;
9070 break;
9071
9072 case 6900: hash_type = HASH_TYPE_GOST;
9073 salt_type = SALT_TYPE_NONE;
9074 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9075 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9076 kern_type = KERN_TYPE_GOST;
9077 dgst_size = DGST_SIZE_4_8;
9078 parse_func = gost_parse_hash;
9079 sort_by_digest = sort_by_digest_4_8;
9080 opti_type = OPTI_TYPE_ZERO_BYTE;
9081 dgst_pos0 = 0;
9082 dgst_pos1 = 1;
9083 dgst_pos2 = 2;
9084 dgst_pos3 = 3;
9085 break;
9086
9087 case 7100: hash_type = HASH_TYPE_SHA512;
9088 salt_type = SALT_TYPE_EMBEDDED;
9089 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9090 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9091 kern_type = KERN_TYPE_PBKDF2_SHA512;
9092 dgst_size = DGST_SIZE_8_16;
9093 parse_func = sha512osx_parse_hash;
9094 sort_by_digest = sort_by_digest_8_16;
9095 opti_type = OPTI_TYPE_ZERO_BYTE
9096 | OPTI_TYPE_USES_BITS_64;
9097 dgst_pos0 = 0;
9098 dgst_pos1 = 1;
9099 dgst_pos2 = 2;
9100 dgst_pos3 = 3;
9101 break;
9102
9103 case 7200: hash_type = HASH_TYPE_SHA512;
9104 salt_type = SALT_TYPE_EMBEDDED;
9105 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9106 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9107 kern_type = KERN_TYPE_PBKDF2_SHA512;
9108 dgst_size = DGST_SIZE_8_16;
9109 parse_func = sha512grub_parse_hash;
9110 sort_by_digest = sort_by_digest_8_16;
9111 opti_type = OPTI_TYPE_ZERO_BYTE
9112 | OPTI_TYPE_USES_BITS_64;
9113 dgst_pos0 = 0;
9114 dgst_pos1 = 1;
9115 dgst_pos2 = 2;
9116 dgst_pos3 = 3;
9117 break;
9118
9119 case 7300: hash_type = HASH_TYPE_SHA1;
9120 salt_type = SALT_TYPE_EMBEDDED;
9121 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9122 opts_type = OPTS_TYPE_PT_GENERATE_BE
9123 | OPTS_TYPE_ST_ADD80
9124 | OPTS_TYPE_ST_ADDBITS15;
9125 kern_type = KERN_TYPE_RAKP;
9126 dgst_size = DGST_SIZE_4_5;
9127 parse_func = rakp_parse_hash;
9128 sort_by_digest = sort_by_digest_4_5;
9129 opti_type = OPTI_TYPE_ZERO_BYTE
9130 | OPTI_TYPE_NOT_ITERATED;
9131 dgst_pos0 = 3;
9132 dgst_pos1 = 4;
9133 dgst_pos2 = 2;
9134 dgst_pos3 = 1;
9135 break;
9136
9137 case 7400: hash_type = HASH_TYPE_SHA256;
9138 salt_type = SALT_TYPE_EMBEDDED;
9139 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9140 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9141 kern_type = KERN_TYPE_SHA256CRYPT;
9142 dgst_size = DGST_SIZE_4_8;
9143 parse_func = sha256crypt_parse_hash;
9144 sort_by_digest = sort_by_digest_4_8;
9145 opti_type = OPTI_TYPE_ZERO_BYTE;
9146 dgst_pos0 = 0;
9147 dgst_pos1 = 1;
9148 dgst_pos2 = 2;
9149 dgst_pos3 = 3;
9150 break;
9151
9152 case 7500: hash_type = HASH_TYPE_KRB5PA;
9153 salt_type = SALT_TYPE_EMBEDDED;
9154 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9155 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9156 kern_type = KERN_TYPE_KRB5PA;
9157 dgst_size = DGST_SIZE_4_4;
9158 parse_func = krb5pa_parse_hash;
9159 sort_by_digest = sort_by_digest_4_4;
9160 opti_type = OPTI_TYPE_ZERO_BYTE
9161 | OPTI_TYPE_NOT_ITERATED;
9162 dgst_pos0 = 0;
9163 dgst_pos1 = 1;
9164 dgst_pos2 = 2;
9165 dgst_pos3 = 3;
9166 break;
9167
9168 case 7600: hash_type = HASH_TYPE_SHA1;
9169 salt_type = SALT_TYPE_INTERN;
9170 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9171 opts_type = OPTS_TYPE_PT_GENERATE_BE
9172 | OPTS_TYPE_PT_ADD80
9173 | OPTS_TYPE_PT_ADDBITS15;
9174 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9175 dgst_size = DGST_SIZE_4_5;
9176 parse_func = redmine_parse_hash;
9177 sort_by_digest = sort_by_digest_4_5;
9178 opti_type = OPTI_TYPE_ZERO_BYTE
9179 | OPTI_TYPE_PRECOMPUTE_INIT
9180 | OPTI_TYPE_EARLY_SKIP
9181 | OPTI_TYPE_NOT_ITERATED
9182 | OPTI_TYPE_PREPENDED_SALT;
9183 dgst_pos0 = 3;
9184 dgst_pos1 = 4;
9185 dgst_pos2 = 2;
9186 dgst_pos3 = 1;
9187 break;
9188
9189 case 7700: hash_type = HASH_TYPE_SAPB;
9190 salt_type = SALT_TYPE_EMBEDDED;
9191 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9192 opts_type = OPTS_TYPE_PT_GENERATE_LE
9193 | OPTS_TYPE_PT_UPPER
9194 | OPTS_TYPE_ST_UPPER;
9195 kern_type = KERN_TYPE_SAPB;
9196 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9197 parse_func = sapb_parse_hash;
9198 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9199 opti_type = OPTI_TYPE_ZERO_BYTE
9200 | OPTI_TYPE_PRECOMPUTE_INIT
9201 | OPTI_TYPE_NOT_ITERATED;
9202 dgst_pos0 = 0;
9203 dgst_pos1 = 1;
9204 dgst_pos2 = 2;
9205 dgst_pos3 = 3;
9206 break;
9207
9208 case 7800: hash_type = HASH_TYPE_SAPG;
9209 salt_type = SALT_TYPE_EMBEDDED;
9210 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9211 opts_type = OPTS_TYPE_PT_GENERATE_BE
9212 | OPTS_TYPE_ST_ADD80
9213 | OPTS_TYPE_ST_UPPER;
9214 kern_type = KERN_TYPE_SAPG;
9215 dgst_size = DGST_SIZE_4_5;
9216 parse_func = sapg_parse_hash;
9217 sort_by_digest = sort_by_digest_4_5;
9218 opti_type = OPTI_TYPE_ZERO_BYTE
9219 | OPTI_TYPE_PRECOMPUTE_INIT
9220 | OPTI_TYPE_NOT_ITERATED;
9221 dgst_pos0 = 3;
9222 dgst_pos1 = 4;
9223 dgst_pos2 = 2;
9224 dgst_pos3 = 1;
9225 break;
9226
9227 case 7900: hash_type = HASH_TYPE_SHA512;
9228 salt_type = SALT_TYPE_EMBEDDED;
9229 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9230 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9231 kern_type = KERN_TYPE_DRUPAL7;
9232 dgst_size = DGST_SIZE_8_8;
9233 parse_func = drupal7_parse_hash;
9234 sort_by_digest = sort_by_digest_8_8;
9235 opti_type = OPTI_TYPE_ZERO_BYTE
9236 | OPTI_TYPE_USES_BITS_64;
9237 dgst_pos0 = 0;
9238 dgst_pos1 = 1;
9239 dgst_pos2 = 2;
9240 dgst_pos3 = 3;
9241 break;
9242
9243 case 8000: hash_type = HASH_TYPE_SHA256;
9244 salt_type = SALT_TYPE_EMBEDDED;
9245 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9246 opts_type = OPTS_TYPE_PT_GENERATE_BE
9247 | OPTS_TYPE_PT_UNICODE
9248 | OPTS_TYPE_ST_ADD80
9249 | OPTS_TYPE_ST_HEX;
9250 kern_type = KERN_TYPE_SYBASEASE;
9251 dgst_size = DGST_SIZE_4_8;
9252 parse_func = sybasease_parse_hash;
9253 sort_by_digest = sort_by_digest_4_8;
9254 opti_type = OPTI_TYPE_ZERO_BYTE
9255 | OPTI_TYPE_PRECOMPUTE_INIT
9256 | OPTI_TYPE_EARLY_SKIP
9257 | OPTI_TYPE_NOT_ITERATED
9258 | OPTI_TYPE_RAW_HASH;
9259 dgst_pos0 = 3;
9260 dgst_pos1 = 7;
9261 dgst_pos2 = 2;
9262 dgst_pos3 = 6;
9263 break;
9264
9265 case 8100: hash_type = HASH_TYPE_SHA1;
9266 salt_type = SALT_TYPE_EMBEDDED;
9267 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9268 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9269 kern_type = KERN_TYPE_NETSCALER;
9270 dgst_size = DGST_SIZE_4_5;
9271 parse_func = netscaler_parse_hash;
9272 sort_by_digest = sort_by_digest_4_5;
9273 opti_type = OPTI_TYPE_ZERO_BYTE
9274 | OPTI_TYPE_PRECOMPUTE_INIT
9275 | OPTI_TYPE_PRECOMPUTE_MERKLE
9276 | OPTI_TYPE_EARLY_SKIP
9277 | OPTI_TYPE_NOT_ITERATED
9278 | OPTI_TYPE_PREPENDED_SALT
9279 | OPTI_TYPE_RAW_HASH;
9280 dgst_pos0 = 3;
9281 dgst_pos1 = 4;
9282 dgst_pos2 = 2;
9283 dgst_pos3 = 1;
9284 break;
9285
9286 case 8200: hash_type = HASH_TYPE_SHA256;
9287 salt_type = SALT_TYPE_EMBEDDED;
9288 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9289 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9290 kern_type = KERN_TYPE_CLOUDKEY;
9291 dgst_size = DGST_SIZE_4_8;
9292 parse_func = cloudkey_parse_hash;
9293 sort_by_digest = sort_by_digest_4_8;
9294 opti_type = OPTI_TYPE_ZERO_BYTE;
9295 dgst_pos0 = 0;
9296 dgst_pos1 = 1;
9297 dgst_pos2 = 2;
9298 dgst_pos3 = 3;
9299 break;
9300
9301 case 8300: hash_type = HASH_TYPE_SHA1;
9302 salt_type = SALT_TYPE_EMBEDDED;
9303 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9304 opts_type = OPTS_TYPE_PT_GENERATE_BE
9305 | OPTS_TYPE_ST_HEX
9306 | OPTS_TYPE_ST_ADD80;
9307 kern_type = KERN_TYPE_NSEC3;
9308 dgst_size = DGST_SIZE_4_5;
9309 parse_func = nsec3_parse_hash;
9310 sort_by_digest = sort_by_digest_4_5;
9311 opti_type = OPTI_TYPE_ZERO_BYTE;
9312 dgst_pos0 = 3;
9313 dgst_pos1 = 4;
9314 dgst_pos2 = 2;
9315 dgst_pos3 = 1;
9316 break;
9317
9318 case 8400: hash_type = HASH_TYPE_SHA1;
9319 salt_type = SALT_TYPE_INTERN;
9320 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9321 opts_type = OPTS_TYPE_PT_GENERATE_BE
9322 | OPTS_TYPE_PT_ADD80
9323 | OPTS_TYPE_PT_ADDBITS15;
9324 kern_type = KERN_TYPE_WBB3;
9325 dgst_size = DGST_SIZE_4_5;
9326 parse_func = wbb3_parse_hash;
9327 sort_by_digest = sort_by_digest_4_5;
9328 opti_type = OPTI_TYPE_ZERO_BYTE
9329 | OPTI_TYPE_PRECOMPUTE_INIT
9330 | OPTI_TYPE_NOT_ITERATED;
9331 dgst_pos0 = 3;
9332 dgst_pos1 = 4;
9333 dgst_pos2 = 2;
9334 dgst_pos3 = 1;
9335 break;
9336
9337 case 8500: hash_type = HASH_TYPE_DESRACF;
9338 salt_type = SALT_TYPE_EMBEDDED;
9339 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9340 opts_type = OPTS_TYPE_PT_GENERATE_LE
9341 | OPTS_TYPE_ST_UPPER;
9342 kern_type = KERN_TYPE_RACF;
9343 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9344 parse_func = racf_parse_hash;
9345 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9346 opti_type = OPTI_TYPE_ZERO_BYTE
9347 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9348 dgst_pos0 = 0;
9349 dgst_pos1 = 1;
9350 dgst_pos2 = 2;
9351 dgst_pos3 = 3;
9352 break;
9353
9354 case 8600: hash_type = HASH_TYPE_LOTUS5;
9355 salt_type = SALT_TYPE_NONE;
9356 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9357 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9358 kern_type = KERN_TYPE_LOTUS5;
9359 dgst_size = DGST_SIZE_4_4;
9360 parse_func = lotus5_parse_hash;
9361 sort_by_digest = sort_by_digest_4_4;
9362 opti_type = OPTI_TYPE_EARLY_SKIP
9363 | OPTI_TYPE_NOT_ITERATED
9364 | OPTI_TYPE_NOT_SALTED
9365 | OPTI_TYPE_RAW_HASH;
9366 dgst_pos0 = 0;
9367 dgst_pos1 = 1;
9368 dgst_pos2 = 2;
9369 dgst_pos3 = 3;
9370 break;
9371
9372 case 8700: hash_type = HASH_TYPE_LOTUS6;
9373 salt_type = SALT_TYPE_EMBEDDED;
9374 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9375 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9376 kern_type = KERN_TYPE_LOTUS6;
9377 dgst_size = DGST_SIZE_4_4;
9378 parse_func = lotus6_parse_hash;
9379 sort_by_digest = sort_by_digest_4_4;
9380 opti_type = OPTI_TYPE_EARLY_SKIP
9381 | OPTI_TYPE_NOT_ITERATED
9382 | OPTI_TYPE_RAW_HASH;
9383 dgst_pos0 = 0;
9384 dgst_pos1 = 1;
9385 dgst_pos2 = 2;
9386 dgst_pos3 = 3;
9387 break;
9388
9389 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9390 salt_type = SALT_TYPE_EMBEDDED;
9391 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9392 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9393 kern_type = KERN_TYPE_ANDROIDFDE;
9394 dgst_size = DGST_SIZE_4_4;
9395 parse_func = androidfde_parse_hash;
9396 sort_by_digest = sort_by_digest_4_4;
9397 opti_type = OPTI_TYPE_ZERO_BYTE;
9398 dgst_pos0 = 0;
9399 dgst_pos1 = 1;
9400 dgst_pos2 = 2;
9401 dgst_pos3 = 3;
9402 break;
9403
9404 case 8900: hash_type = HASH_TYPE_SCRYPT;
9405 salt_type = SALT_TYPE_EMBEDDED;
9406 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9407 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9408 kern_type = KERN_TYPE_SCRYPT;
9409 dgst_size = DGST_SIZE_4_8;
9410 parse_func = scrypt_parse_hash;
9411 sort_by_digest = sort_by_digest_4_8;
9412 opti_type = OPTI_TYPE_ZERO_BYTE;
9413 dgst_pos0 = 0;
9414 dgst_pos1 = 1;
9415 dgst_pos2 = 2;
9416 dgst_pos3 = 3;
9417 break;
9418
9419 case 9000: hash_type = HASH_TYPE_SHA1;
9420 salt_type = SALT_TYPE_EMBEDDED;
9421 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9422 opts_type = OPTS_TYPE_PT_GENERATE_LE
9423 | OPTS_TYPE_ST_GENERATE_LE;
9424 kern_type = KERN_TYPE_PSAFE2;
9425 dgst_size = DGST_SIZE_4_5;
9426 parse_func = psafe2_parse_hash;
9427 sort_by_digest = sort_by_digest_4_5;
9428 opti_type = OPTI_TYPE_ZERO_BYTE;
9429 dgst_pos0 = 0;
9430 dgst_pos1 = 1;
9431 dgst_pos2 = 2;
9432 dgst_pos3 = 3;
9433 break;
9434
9435 case 9100: hash_type = HASH_TYPE_LOTUS8;
9436 salt_type = SALT_TYPE_EMBEDDED;
9437 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9438 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9439 kern_type = KERN_TYPE_LOTUS8;
9440 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9441 parse_func = lotus8_parse_hash;
9442 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9443 opti_type = OPTI_TYPE_ZERO_BYTE;
9444 dgst_pos0 = 0;
9445 dgst_pos1 = 1;
9446 dgst_pos2 = 2;
9447 dgst_pos3 = 3;
9448 break;
9449
9450 case 9200: hash_type = HASH_TYPE_SHA256;
9451 salt_type = SALT_TYPE_EMBEDDED;
9452 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9453 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9454 kern_type = KERN_TYPE_PBKDF2_SHA256;
9455 dgst_size = DGST_SIZE_4_32;
9456 parse_func = cisco8_parse_hash;
9457 sort_by_digest = sort_by_digest_4_32;
9458 opti_type = OPTI_TYPE_ZERO_BYTE;
9459 dgst_pos0 = 0;
9460 dgst_pos1 = 1;
9461 dgst_pos2 = 2;
9462 dgst_pos3 = 3;
9463 break;
9464
9465 case 9300: hash_type = HASH_TYPE_SCRYPT;
9466 salt_type = SALT_TYPE_EMBEDDED;
9467 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9468 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9469 kern_type = KERN_TYPE_SCRYPT;
9470 dgst_size = DGST_SIZE_4_8;
9471 parse_func = cisco9_parse_hash;
9472 sort_by_digest = sort_by_digest_4_8;
9473 opti_type = OPTI_TYPE_ZERO_BYTE;
9474 dgst_pos0 = 0;
9475 dgst_pos1 = 1;
9476 dgst_pos2 = 2;
9477 dgst_pos3 = 3;
9478 break;
9479
9480 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9481 salt_type = SALT_TYPE_EMBEDDED;
9482 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9483 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9484 kern_type = KERN_TYPE_OFFICE2007;
9485 dgst_size = DGST_SIZE_4_4;
9486 parse_func = office2007_parse_hash;
9487 sort_by_digest = sort_by_digest_4_4;
9488 opti_type = OPTI_TYPE_ZERO_BYTE;
9489 dgst_pos0 = 0;
9490 dgst_pos1 = 1;
9491 dgst_pos2 = 2;
9492 dgst_pos3 = 3;
9493 break;
9494
9495 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9496 salt_type = SALT_TYPE_EMBEDDED;
9497 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9498 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9499 kern_type = KERN_TYPE_OFFICE2010;
9500 dgst_size = DGST_SIZE_4_4;
9501 parse_func = office2010_parse_hash;
9502 sort_by_digest = sort_by_digest_4_4;
9503 opti_type = OPTI_TYPE_ZERO_BYTE;
9504 dgst_pos0 = 0;
9505 dgst_pos1 = 1;
9506 dgst_pos2 = 2;
9507 dgst_pos3 = 3;
9508 break;
9509
9510 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9511 salt_type = SALT_TYPE_EMBEDDED;
9512 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9513 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9514 kern_type = KERN_TYPE_OFFICE2013;
9515 dgst_size = DGST_SIZE_4_4;
9516 parse_func = office2013_parse_hash;
9517 sort_by_digest = sort_by_digest_4_4;
9518 opti_type = OPTI_TYPE_ZERO_BYTE;
9519 dgst_pos0 = 0;
9520 dgst_pos1 = 1;
9521 dgst_pos2 = 2;
9522 dgst_pos3 = 3;
9523 break;
9524
9525 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9526 salt_type = SALT_TYPE_EMBEDDED;
9527 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9528 opts_type = OPTS_TYPE_PT_GENERATE_LE
9529 | OPTS_TYPE_PT_ADD80
9530 | OPTS_TYPE_PT_UNICODE;
9531 kern_type = KERN_TYPE_OLDOFFICE01;
9532 dgst_size = DGST_SIZE_4_4;
9533 parse_func = oldoffice01_parse_hash;
9534 sort_by_digest = sort_by_digest_4_4;
9535 opti_type = OPTI_TYPE_ZERO_BYTE
9536 | OPTI_TYPE_PRECOMPUTE_INIT
9537 | OPTI_TYPE_NOT_ITERATED;
9538 dgst_pos0 = 0;
9539 dgst_pos1 = 1;
9540 dgst_pos2 = 2;
9541 dgst_pos3 = 3;
9542 break;
9543
9544 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9545 salt_type = SALT_TYPE_EMBEDDED;
9546 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9547 opts_type = OPTS_TYPE_PT_GENERATE_LE
9548 | OPTS_TYPE_PT_ADD80;
9549 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9550 dgst_size = DGST_SIZE_4_4;
9551 parse_func = oldoffice01cm1_parse_hash;
9552 sort_by_digest = sort_by_digest_4_4;
9553 opti_type = OPTI_TYPE_ZERO_BYTE
9554 | OPTI_TYPE_PRECOMPUTE_INIT
9555 | OPTI_TYPE_NOT_ITERATED;
9556 dgst_pos0 = 0;
9557 dgst_pos1 = 1;
9558 dgst_pos2 = 2;
9559 dgst_pos3 = 3;
9560 break;
9561
9562 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9563 salt_type = SALT_TYPE_EMBEDDED;
9564 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9565 opts_type = OPTS_TYPE_PT_GENERATE_LE
9566 | OPTS_TYPE_PT_ADD80
9567 | OPTS_TYPE_PT_UNICODE
9568 | OPTS_TYPE_PT_NEVERCRACK;
9569 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9570 dgst_size = DGST_SIZE_4_4;
9571 parse_func = oldoffice01cm2_parse_hash;
9572 sort_by_digest = sort_by_digest_4_4;
9573 opti_type = OPTI_TYPE_ZERO_BYTE
9574 | OPTI_TYPE_PRECOMPUTE_INIT
9575 | OPTI_TYPE_NOT_ITERATED;
9576 dgst_pos0 = 0;
9577 dgst_pos1 = 1;
9578 dgst_pos2 = 2;
9579 dgst_pos3 = 3;
9580 break;
9581
9582 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9583 salt_type = SALT_TYPE_EMBEDDED;
9584 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9585 opts_type = OPTS_TYPE_PT_GENERATE_BE
9586 | OPTS_TYPE_PT_ADD80
9587 | OPTS_TYPE_PT_UNICODE;
9588 kern_type = KERN_TYPE_OLDOFFICE34;
9589 dgst_size = DGST_SIZE_4_4;
9590 parse_func = oldoffice34_parse_hash;
9591 sort_by_digest = sort_by_digest_4_4;
9592 opti_type = OPTI_TYPE_ZERO_BYTE
9593 | OPTI_TYPE_PRECOMPUTE_INIT
9594 | OPTI_TYPE_NOT_ITERATED;
9595 dgst_pos0 = 0;
9596 dgst_pos1 = 1;
9597 dgst_pos2 = 2;
9598 dgst_pos3 = 3;
9599 break;
9600
9601 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9602 salt_type = SALT_TYPE_EMBEDDED;
9603 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9604 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9605 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9606 dgst_size = DGST_SIZE_4_4;
9607 parse_func = oldoffice34cm1_parse_hash;
9608 sort_by_digest = sort_by_digest_4_4;
9609 opti_type = OPTI_TYPE_ZERO_BYTE
9610 | OPTI_TYPE_PRECOMPUTE_INIT
9611 | OPTI_TYPE_NOT_ITERATED;
9612 dgst_pos0 = 0;
9613 dgst_pos1 = 1;
9614 dgst_pos2 = 2;
9615 dgst_pos3 = 3;
9616 break;
9617
9618 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9619 salt_type = SALT_TYPE_EMBEDDED;
9620 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9621 opts_type = OPTS_TYPE_PT_GENERATE_BE
9622 | OPTS_TYPE_PT_ADD80
9623 | OPTS_TYPE_PT_UNICODE
9624 | OPTS_TYPE_PT_NEVERCRACK;
9625 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9626 dgst_size = DGST_SIZE_4_4;
9627 parse_func = oldoffice34cm2_parse_hash;
9628 sort_by_digest = sort_by_digest_4_4;
9629 opti_type = OPTI_TYPE_ZERO_BYTE
9630 | OPTI_TYPE_PRECOMPUTE_INIT
9631 | OPTI_TYPE_NOT_ITERATED;
9632 dgst_pos0 = 0;
9633 dgst_pos1 = 1;
9634 dgst_pos2 = 2;
9635 dgst_pos3 = 3;
9636 break;
9637
9638 case 9900: hash_type = HASH_TYPE_MD5;
9639 salt_type = SALT_TYPE_NONE;
9640 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9641 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9642 kern_type = KERN_TYPE_RADMIN2;
9643 dgst_size = DGST_SIZE_4_4;
9644 parse_func = radmin2_parse_hash;
9645 sort_by_digest = sort_by_digest_4_4;
9646 opti_type = OPTI_TYPE_ZERO_BYTE
9647 | OPTI_TYPE_PRECOMPUTE_INIT
9648 | OPTI_TYPE_EARLY_SKIP
9649 | OPTI_TYPE_NOT_ITERATED
9650 | OPTI_TYPE_NOT_SALTED;
9651 dgst_pos0 = 0;
9652 dgst_pos1 = 3;
9653 dgst_pos2 = 2;
9654 dgst_pos3 = 1;
9655 break;
9656
9657 case 10000: hash_type = HASH_TYPE_SHA256;
9658 salt_type = SALT_TYPE_EMBEDDED;
9659 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9660 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9661 kern_type = KERN_TYPE_PBKDF2_SHA256;
9662 dgst_size = DGST_SIZE_4_32;
9663 parse_func = djangopbkdf2_parse_hash;
9664 sort_by_digest = sort_by_digest_4_32;
9665 opti_type = OPTI_TYPE_ZERO_BYTE;
9666 dgst_pos0 = 0;
9667 dgst_pos1 = 1;
9668 dgst_pos2 = 2;
9669 dgst_pos3 = 3;
9670 break;
9671
9672 case 10100: hash_type = HASH_TYPE_SIPHASH;
9673 salt_type = SALT_TYPE_EMBEDDED;
9674 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9675 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9676 kern_type = KERN_TYPE_SIPHASH;
9677 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9678 parse_func = siphash_parse_hash;
9679 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9680 opti_type = OPTI_TYPE_ZERO_BYTE
9681 | OPTI_TYPE_NOT_ITERATED
9682 | OPTI_TYPE_RAW_HASH;
9683 dgst_pos0 = 0;
9684 dgst_pos1 = 1;
9685 dgst_pos2 = 2;
9686 dgst_pos3 = 3;
9687 break;
9688
9689 case 10200: hash_type = HASH_TYPE_MD5;
9690 salt_type = SALT_TYPE_EMBEDDED;
9691 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9692 opts_type = OPTS_TYPE_PT_GENERATE_LE
9693 | OPTS_TYPE_ST_ADD80
9694 | OPTS_TYPE_ST_ADDBITS14;
9695 kern_type = KERN_TYPE_HMACMD5_PW;
9696 dgst_size = DGST_SIZE_4_4;
9697 parse_func = crammd5_parse_hash;
9698 sort_by_digest = sort_by_digest_4_4;
9699 opti_type = OPTI_TYPE_ZERO_BYTE
9700 | OPTI_TYPE_NOT_ITERATED;
9701 dgst_pos0 = 0;
9702 dgst_pos1 = 3;
9703 dgst_pos2 = 2;
9704 dgst_pos3 = 1;
9705 break;
9706
9707 case 10300: hash_type = HASH_TYPE_SHA1;
9708 salt_type = SALT_TYPE_EMBEDDED;
9709 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9710 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9711 kern_type = KERN_TYPE_SAPH_SHA1;
9712 dgst_size = DGST_SIZE_4_5;
9713 parse_func = saph_sha1_parse_hash;
9714 sort_by_digest = sort_by_digest_4_5;
9715 opti_type = OPTI_TYPE_ZERO_BYTE;
9716 dgst_pos0 = 0;
9717 dgst_pos1 = 1;
9718 dgst_pos2 = 2;
9719 dgst_pos3 = 3;
9720 break;
9721
9722 case 10400: hash_type = HASH_TYPE_PDFU16;
9723 salt_type = SALT_TYPE_EMBEDDED;
9724 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9725 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9726 kern_type = KERN_TYPE_PDF11;
9727 dgst_size = DGST_SIZE_4_4;
9728 parse_func = pdf11_parse_hash;
9729 sort_by_digest = sort_by_digest_4_4;
9730 opti_type = OPTI_TYPE_ZERO_BYTE
9731 | OPTI_TYPE_NOT_ITERATED;
9732 dgst_pos0 = 0;
9733 dgst_pos1 = 1;
9734 dgst_pos2 = 2;
9735 dgst_pos3 = 3;
9736 break;
9737
9738 case 10410: hash_type = HASH_TYPE_PDFU16;
9739 salt_type = SALT_TYPE_EMBEDDED;
9740 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9741 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9742 kern_type = KERN_TYPE_PDF11CM1;
9743 dgst_size = DGST_SIZE_4_4;
9744 parse_func = pdf11cm1_parse_hash;
9745 sort_by_digest = sort_by_digest_4_4;
9746 opti_type = OPTI_TYPE_ZERO_BYTE
9747 | OPTI_TYPE_NOT_ITERATED;
9748 dgst_pos0 = 0;
9749 dgst_pos1 = 1;
9750 dgst_pos2 = 2;
9751 dgst_pos3 = 3;
9752 break;
9753
9754 case 10420: hash_type = HASH_TYPE_PDFU16;
9755 salt_type = SALT_TYPE_EMBEDDED;
9756 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9757 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9758 kern_type = KERN_TYPE_PDF11CM2;
9759 dgst_size = DGST_SIZE_4_4;
9760 parse_func = pdf11cm2_parse_hash;
9761 sort_by_digest = sort_by_digest_4_4;
9762 opti_type = OPTI_TYPE_ZERO_BYTE
9763 | OPTI_TYPE_NOT_ITERATED;
9764 dgst_pos0 = 0;
9765 dgst_pos1 = 1;
9766 dgst_pos2 = 2;
9767 dgst_pos3 = 3;
9768 break;
9769
9770 case 10500: hash_type = HASH_TYPE_PDFU16;
9771 salt_type = SALT_TYPE_EMBEDDED;
9772 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9773 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9774 kern_type = KERN_TYPE_PDF14;
9775 dgst_size = DGST_SIZE_4_4;
9776 parse_func = pdf14_parse_hash;
9777 sort_by_digest = sort_by_digest_4_4;
9778 opti_type = OPTI_TYPE_ZERO_BYTE
9779 | OPTI_TYPE_NOT_ITERATED;
9780 dgst_pos0 = 0;
9781 dgst_pos1 = 1;
9782 dgst_pos2 = 2;
9783 dgst_pos3 = 3;
9784 break;
9785
9786 case 10600: hash_type = HASH_TYPE_SHA256;
9787 salt_type = SALT_TYPE_EMBEDDED;
9788 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9789 opts_type = OPTS_TYPE_PT_GENERATE_BE
9790 | OPTS_TYPE_ST_ADD80
9791 | OPTS_TYPE_ST_ADDBITS15
9792 | OPTS_TYPE_HASH_COPY;
9793 kern_type = KERN_TYPE_SHA256_PWSLT;
9794 dgst_size = DGST_SIZE_4_8;
9795 parse_func = pdf17l3_parse_hash;
9796 sort_by_digest = sort_by_digest_4_8;
9797 opti_type = OPTI_TYPE_ZERO_BYTE
9798 | OPTI_TYPE_PRECOMPUTE_INIT
9799 | OPTI_TYPE_PRECOMPUTE_MERKLE
9800 | OPTI_TYPE_EARLY_SKIP
9801 | OPTI_TYPE_NOT_ITERATED
9802 | OPTI_TYPE_APPENDED_SALT
9803 | OPTI_TYPE_RAW_HASH;
9804 dgst_pos0 = 3;
9805 dgst_pos1 = 7;
9806 dgst_pos2 = 2;
9807 dgst_pos3 = 6;
9808 break;
9809
9810 case 10700: hash_type = HASH_TYPE_PDFU32;
9811 salt_type = SALT_TYPE_EMBEDDED;
9812 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9813 opts_type = OPTS_TYPE_PT_GENERATE_LE
9814 | OPTS_TYPE_HASH_COPY;
9815 kern_type = KERN_TYPE_PDF17L8;
9816 dgst_size = DGST_SIZE_4_8;
9817 parse_func = pdf17l8_parse_hash;
9818 sort_by_digest = sort_by_digest_4_8;
9819 opti_type = OPTI_TYPE_ZERO_BYTE
9820 | OPTI_TYPE_NOT_ITERATED;
9821 dgst_pos0 = 0;
9822 dgst_pos1 = 1;
9823 dgst_pos2 = 2;
9824 dgst_pos3 = 3;
9825 break;
9826
9827 case 10800: hash_type = HASH_TYPE_SHA384;
9828 salt_type = SALT_TYPE_NONE;
9829 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9830 opts_type = OPTS_TYPE_PT_GENERATE_BE
9831 | OPTS_TYPE_PT_ADD80
9832 | OPTS_TYPE_PT_ADDBITS15;
9833 kern_type = KERN_TYPE_SHA384;
9834 dgst_size = DGST_SIZE_8_8;
9835 parse_func = sha384_parse_hash;
9836 sort_by_digest = sort_by_digest_8_8;
9837 opti_type = OPTI_TYPE_ZERO_BYTE
9838 | OPTI_TYPE_PRECOMPUTE_INIT
9839 | OPTI_TYPE_PRECOMPUTE_MERKLE
9840 | OPTI_TYPE_EARLY_SKIP
9841 | OPTI_TYPE_NOT_ITERATED
9842 | OPTI_TYPE_NOT_SALTED
9843 | OPTI_TYPE_USES_BITS_64
9844 | OPTI_TYPE_RAW_HASH;
9845 dgst_pos0 = 6;
9846 dgst_pos1 = 7;
9847 dgst_pos2 = 4;
9848 dgst_pos3 = 5;
9849 break;
9850
9851 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9852 salt_type = SALT_TYPE_EMBEDDED;
9853 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9854 opts_type = OPTS_TYPE_PT_GENERATE_LE
9855 | OPTS_TYPE_ST_BASE64
9856 | OPTS_TYPE_HASH_COPY;
9857 kern_type = KERN_TYPE_PBKDF2_SHA256;
9858 dgst_size = DGST_SIZE_4_32;
9859 parse_func = pbkdf2_sha256_parse_hash;
9860 sort_by_digest = sort_by_digest_4_32;
9861 opti_type = OPTI_TYPE_ZERO_BYTE;
9862 dgst_pos0 = 0;
9863 dgst_pos1 = 1;
9864 dgst_pos2 = 2;
9865 dgst_pos3 = 3;
9866 break;
9867
9868 case 11000: hash_type = HASH_TYPE_MD5;
9869 salt_type = SALT_TYPE_INTERN;
9870 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9871 opts_type = OPTS_TYPE_PT_GENERATE_LE
9872 | OPTS_TYPE_PT_ADD80;
9873 kern_type = KERN_TYPE_PRESTASHOP;
9874 dgst_size = DGST_SIZE_4_4;
9875 parse_func = prestashop_parse_hash;
9876 sort_by_digest = sort_by_digest_4_4;
9877 opti_type = OPTI_TYPE_ZERO_BYTE
9878 | OPTI_TYPE_PRECOMPUTE_INIT
9879 | OPTI_TYPE_NOT_ITERATED
9880 | OPTI_TYPE_PREPENDED_SALT;
9881 dgst_pos0 = 0;
9882 dgst_pos1 = 3;
9883 dgst_pos2 = 2;
9884 dgst_pos3 = 1;
9885 break;
9886
9887 case 11100: hash_type = HASH_TYPE_MD5;
9888 salt_type = SALT_TYPE_EMBEDDED;
9889 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9890 opts_type = OPTS_TYPE_PT_GENERATE_LE
9891 | OPTS_TYPE_ST_ADD80;
9892 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9893 dgst_size = DGST_SIZE_4_4;
9894 parse_func = postgresql_auth_parse_hash;
9895 sort_by_digest = sort_by_digest_4_4;
9896 opti_type = OPTI_TYPE_ZERO_BYTE
9897 | OPTI_TYPE_PRECOMPUTE_INIT
9898 | OPTI_TYPE_PRECOMPUTE_MERKLE
9899 | OPTI_TYPE_EARLY_SKIP;
9900 dgst_pos0 = 0;
9901 dgst_pos1 = 3;
9902 dgst_pos2 = 2;
9903 dgst_pos3 = 1;
9904 break;
9905
9906 case 11200: hash_type = HASH_TYPE_SHA1;
9907 salt_type = SALT_TYPE_EMBEDDED;
9908 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9909 opts_type = OPTS_TYPE_PT_GENERATE_BE
9910 | OPTS_TYPE_PT_ADD80
9911 | OPTS_TYPE_ST_HEX;
9912 kern_type = KERN_TYPE_MYSQL_AUTH;
9913 dgst_size = DGST_SIZE_4_5;
9914 parse_func = mysql_auth_parse_hash;
9915 sort_by_digest = sort_by_digest_4_5;
9916 opti_type = OPTI_TYPE_ZERO_BYTE
9917 | OPTI_TYPE_EARLY_SKIP;
9918 dgst_pos0 = 3;
9919 dgst_pos1 = 4;
9920 dgst_pos2 = 2;
9921 dgst_pos3 = 1;
9922 break;
9923
9924 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9925 salt_type = SALT_TYPE_EMBEDDED;
9926 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9927 opts_type = OPTS_TYPE_PT_GENERATE_LE
9928 | OPTS_TYPE_ST_HEX
9929 | OPTS_TYPE_ST_ADD80;
9930 kern_type = KERN_TYPE_BITCOIN_WALLET;
9931 dgst_size = DGST_SIZE_4_4;
9932 parse_func = bitcoin_wallet_parse_hash;
9933 sort_by_digest = sort_by_digest_4_4;
9934 opti_type = OPTI_TYPE_ZERO_BYTE;
9935 dgst_pos0 = 0;
9936 dgst_pos1 = 1;
9937 dgst_pos2 = 2;
9938 dgst_pos3 = 3;
9939 break;
9940
9941 case 11400: hash_type = HASH_TYPE_MD5;
9942 salt_type = SALT_TYPE_EMBEDDED;
9943 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9944 opts_type = OPTS_TYPE_PT_GENERATE_LE
9945 | OPTS_TYPE_PT_ADD80
9946 | OPTS_TYPE_HASH_COPY;
9947 kern_type = KERN_TYPE_SIP_AUTH;
9948 dgst_size = DGST_SIZE_4_4;
9949 parse_func = sip_auth_parse_hash;
9950 sort_by_digest = sort_by_digest_4_4;
9951 opti_type = OPTI_TYPE_ZERO_BYTE;
9952 dgst_pos0 = 0;
9953 dgst_pos1 = 3;
9954 dgst_pos2 = 2;
9955 dgst_pos3 = 1;
9956 break;
9957
9958 case 11500: hash_type = HASH_TYPE_CRC32;
9959 salt_type = SALT_TYPE_INTERN;
9960 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9961 opts_type = OPTS_TYPE_PT_GENERATE_LE
9962 | OPTS_TYPE_ST_GENERATE_LE
9963 | OPTS_TYPE_ST_HEX;
9964 kern_type = KERN_TYPE_CRC32;
9965 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9966 parse_func = crc32_parse_hash;
9967 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9968 opti_type = OPTI_TYPE_ZERO_BYTE;
9969 dgst_pos0 = 0;
9970 dgst_pos1 = 1;
9971 dgst_pos2 = 2;
9972 dgst_pos3 = 3;
9973 break;
9974
9975 case 11600: hash_type = HASH_TYPE_AES;
9976 salt_type = SALT_TYPE_EMBEDDED;
9977 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9978 opts_type = OPTS_TYPE_PT_GENERATE_LE
9979 | OPTS_TYPE_PT_NEVERCRACK;
9980 kern_type = KERN_TYPE_SEVEN_ZIP;
9981 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9982 parse_func = seven_zip_parse_hash;
9983 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9984 opti_type = OPTI_TYPE_ZERO_BYTE;
9985 dgst_pos0 = 0;
9986 dgst_pos1 = 1;
9987 dgst_pos2 = 2;
9988 dgst_pos3 = 3;
9989 break;
9990
9991 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9992 salt_type = SALT_TYPE_NONE;
9993 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9994 opts_type = OPTS_TYPE_PT_GENERATE_LE
9995 | OPTS_TYPE_PT_ADD01;
9996 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9997 dgst_size = DGST_SIZE_4_8;
9998 parse_func = gost2012sbog_256_parse_hash;
9999 sort_by_digest = sort_by_digest_4_8;
10000 opti_type = OPTI_TYPE_ZERO_BYTE;
10001 dgst_pos0 = 0;
10002 dgst_pos1 = 1;
10003 dgst_pos2 = 2;
10004 dgst_pos3 = 3;
10005 break;
10006
10007 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10008 salt_type = SALT_TYPE_NONE;
10009 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10010 opts_type = OPTS_TYPE_PT_GENERATE_LE
10011 | OPTS_TYPE_PT_ADD01;
10012 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10013 dgst_size = DGST_SIZE_4_16;
10014 parse_func = gost2012sbog_512_parse_hash;
10015 sort_by_digest = sort_by_digest_4_16;
10016 opti_type = OPTI_TYPE_ZERO_BYTE;
10017 dgst_pos0 = 0;
10018 dgst_pos1 = 1;
10019 dgst_pos2 = 2;
10020 dgst_pos3 = 3;
10021 break;
10022
10023 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10024 salt_type = SALT_TYPE_EMBEDDED;
10025 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10026 opts_type = OPTS_TYPE_PT_GENERATE_LE
10027 | OPTS_TYPE_ST_BASE64
10028 | OPTS_TYPE_HASH_COPY;
10029 kern_type = KERN_TYPE_PBKDF2_MD5;
10030 dgst_size = DGST_SIZE_4_32;
10031 parse_func = pbkdf2_md5_parse_hash;
10032 sort_by_digest = sort_by_digest_4_32;
10033 opti_type = OPTI_TYPE_ZERO_BYTE;
10034 dgst_pos0 = 0;
10035 dgst_pos1 = 1;
10036 dgst_pos2 = 2;
10037 dgst_pos3 = 3;
10038 break;
10039
10040 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10041 salt_type = SALT_TYPE_EMBEDDED;
10042 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10043 opts_type = OPTS_TYPE_PT_GENERATE_LE
10044 | OPTS_TYPE_ST_BASE64
10045 | OPTS_TYPE_HASH_COPY;
10046 kern_type = KERN_TYPE_PBKDF2_SHA1;
10047 dgst_size = DGST_SIZE_4_32;
10048 parse_func = pbkdf2_sha1_parse_hash;
10049 sort_by_digest = sort_by_digest_4_32;
10050 opti_type = OPTI_TYPE_ZERO_BYTE;
10051 dgst_pos0 = 0;
10052 dgst_pos1 = 1;
10053 dgst_pos2 = 2;
10054 dgst_pos3 = 3;
10055 break;
10056
10057 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10058 salt_type = SALT_TYPE_EMBEDDED;
10059 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10060 opts_type = OPTS_TYPE_PT_GENERATE_LE
10061 | OPTS_TYPE_ST_BASE64
10062 | OPTS_TYPE_HASH_COPY;
10063 kern_type = KERN_TYPE_PBKDF2_SHA512;
10064 dgst_size = DGST_SIZE_8_16;
10065 parse_func = pbkdf2_sha512_parse_hash;
10066 sort_by_digest = sort_by_digest_8_16;
10067 opti_type = OPTI_TYPE_ZERO_BYTE
10068 | OPTI_TYPE_USES_BITS_64;
10069 dgst_pos0 = 0;
10070 dgst_pos1 = 1;
10071 dgst_pos2 = 2;
10072 dgst_pos3 = 3;
10073 break;
10074
10075 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10076 salt_type = SALT_TYPE_EMBEDDED;
10077 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10078 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10079 kern_type = KERN_TYPE_ECRYPTFS;
10080 dgst_size = DGST_SIZE_8_8;
10081 parse_func = ecryptfs_parse_hash;
10082 sort_by_digest = sort_by_digest_8_8;
10083 opti_type = OPTI_TYPE_ZERO_BYTE
10084 | OPTI_TYPE_USES_BITS_64;
10085 dgst_pos0 = 0;
10086 dgst_pos1 = 1;
10087 dgst_pos2 = 2;
10088 dgst_pos3 = 3;
10089 break;
10090
10091 case 12300: hash_type = HASH_TYPE_ORACLET;
10092 salt_type = SALT_TYPE_EMBEDDED;
10093 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10094 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10095 kern_type = KERN_TYPE_ORACLET;
10096 dgst_size = DGST_SIZE_8_16;
10097 parse_func = oraclet_parse_hash;
10098 sort_by_digest = sort_by_digest_8_16;
10099 opti_type = OPTI_TYPE_ZERO_BYTE
10100 | OPTI_TYPE_USES_BITS_64;
10101 dgst_pos0 = 0;
10102 dgst_pos1 = 1;
10103 dgst_pos2 = 2;
10104 dgst_pos3 = 3;
10105 break;
10106
10107 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10108 salt_type = SALT_TYPE_EMBEDDED;
10109 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10110 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10111 kern_type = KERN_TYPE_BSDICRYPT;
10112 dgst_size = DGST_SIZE_4_4;
10113 parse_func = bsdicrypt_parse_hash;
10114 sort_by_digest = sort_by_digest_4_4;
10115 opti_type = OPTI_TYPE_ZERO_BYTE
10116 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10117 dgst_pos0 = 0;
10118 dgst_pos1 = 1;
10119 dgst_pos2 = 2;
10120 dgst_pos3 = 3;
10121 break;
10122
10123 case 12500: hash_type = HASH_TYPE_RAR3HP;
10124 salt_type = SALT_TYPE_EMBEDDED;
10125 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10126 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10127 kern_type = KERN_TYPE_RAR3;
10128 dgst_size = DGST_SIZE_4_4;
10129 parse_func = rar3hp_parse_hash;
10130 sort_by_digest = sort_by_digest_4_4;
10131 opti_type = OPTI_TYPE_ZERO_BYTE;
10132 dgst_pos0 = 0;
10133 dgst_pos1 = 1;
10134 dgst_pos2 = 2;
10135 dgst_pos3 = 3;
10136 break;
10137
10138 case 12600: hash_type = HASH_TYPE_SHA256;
10139 salt_type = SALT_TYPE_INTERN;
10140 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10141 opts_type = OPTS_TYPE_PT_GENERATE_BE
10142 | OPTS_TYPE_PT_ADD80;
10143 kern_type = KERN_TYPE_CF10;
10144 dgst_size = DGST_SIZE_4_8;
10145 parse_func = cf10_parse_hash;
10146 sort_by_digest = sort_by_digest_4_8;
10147 opti_type = OPTI_TYPE_ZERO_BYTE
10148 | OPTI_TYPE_PRECOMPUTE_INIT
10149 | OPTI_TYPE_EARLY_SKIP
10150 | OPTI_TYPE_NOT_ITERATED;
10151 dgst_pos0 = 3;
10152 dgst_pos1 = 7;
10153 dgst_pos2 = 2;
10154 dgst_pos3 = 6;
10155 break;
10156
10157 case 12700: hash_type = HASH_TYPE_AES;
10158 salt_type = SALT_TYPE_EMBEDDED;
10159 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10160 opts_type = OPTS_TYPE_PT_GENERATE_LE
10161 | OPTS_TYPE_HASH_COPY;
10162 kern_type = KERN_TYPE_MYWALLET;
10163 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10164 parse_func = mywallet_parse_hash;
10165 sort_by_digest = sort_by_digest_4_5;
10166 opti_type = OPTI_TYPE_ZERO_BYTE;
10167 dgst_pos0 = 0;
10168 dgst_pos1 = 1;
10169 dgst_pos2 = 2;
10170 dgst_pos3 = 3;
10171 break;
10172
10173 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10174 salt_type = SALT_TYPE_EMBEDDED;
10175 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10176 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10177 kern_type = KERN_TYPE_MS_DRSR;
10178 dgst_size = DGST_SIZE_4_8;
10179 parse_func = ms_drsr_parse_hash;
10180 sort_by_digest = sort_by_digest_4_8;
10181 opti_type = OPTI_TYPE_ZERO_BYTE;
10182 dgst_pos0 = 0;
10183 dgst_pos1 = 1;
10184 dgst_pos2 = 2;
10185 dgst_pos3 = 3;
10186 break;
10187
10188 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10189 salt_type = SALT_TYPE_EMBEDDED;
10190 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10191 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10192 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10193 dgst_size = DGST_SIZE_4_8;
10194 parse_func = androidfde_samsung_parse_hash;
10195 sort_by_digest = sort_by_digest_4_8;
10196 opti_type = OPTI_TYPE_ZERO_BYTE;
10197 dgst_pos0 = 0;
10198 dgst_pos1 = 1;
10199 dgst_pos2 = 2;
10200 dgst_pos3 = 3;
10201 break;
10202
10203 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10204 salt_type = SALT_TYPE_EMBEDDED;
10205 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10206 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10207 kern_type = KERN_TYPE_RAR5;
10208 dgst_size = DGST_SIZE_4_4;
10209 parse_func = rar5_parse_hash;
10210 sort_by_digest = sort_by_digest_4_4;
10211 opti_type = OPTI_TYPE_ZERO_BYTE;
10212 dgst_pos0 = 0;
10213 dgst_pos1 = 1;
10214 dgst_pos2 = 2;
10215 dgst_pos3 = 3;
10216 break;
10217
10218 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10219 salt_type = SALT_TYPE_EMBEDDED;
10220 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10221 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10222 kern_type = KERN_TYPE_KRB5TGS;
10223 dgst_size = DGST_SIZE_4_4;
10224 parse_func = krb5tgs_parse_hash;
10225 sort_by_digest = sort_by_digest_4_4;
10226 opti_type = OPTI_TYPE_ZERO_BYTE
10227 | OPTI_TYPE_NOT_ITERATED;
10228 dgst_pos0 = 0;
10229 dgst_pos1 = 1;
10230 dgst_pos2 = 2;
10231 dgst_pos3 = 3;
10232 break;
10233
10234 case 13200: hash_type = HASH_TYPE_AES;
10235 salt_type = SALT_TYPE_EMBEDDED;
10236 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10237 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10238 kern_type = KERN_TYPE_AXCRYPT;
10239 dgst_size = DGST_SIZE_4_4;
10240 parse_func = axcrypt_parse_hash;
10241 sort_by_digest = sort_by_digest_4_4;
10242 opti_type = OPTI_TYPE_ZERO_BYTE;
10243 dgst_pos0 = 0;
10244 dgst_pos1 = 1;
10245 dgst_pos2 = 2;
10246 dgst_pos3 = 3;
10247 break;
10248
10249 case 13300: hash_type = HASH_TYPE_SHA1;
10250 salt_type = SALT_TYPE_NONE;
10251 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10252 opts_type = OPTS_TYPE_PT_GENERATE_BE
10253 | OPTS_TYPE_PT_ADD80
10254 | OPTS_TYPE_PT_ADDBITS15;
10255 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10256 dgst_size = DGST_SIZE_4_5;
10257 parse_func = sha1axcrypt_parse_hash;
10258 sort_by_digest = sort_by_digest_4_5;
10259 opti_type = OPTI_TYPE_ZERO_BYTE
10260 | OPTI_TYPE_PRECOMPUTE_INIT
10261 | OPTI_TYPE_EARLY_SKIP
10262 | OPTI_TYPE_NOT_ITERATED
10263 | OPTI_TYPE_NOT_SALTED;
10264 dgst_pos0 = 0;
10265 dgst_pos1 = 4;
10266 dgst_pos2 = 3;
10267 dgst_pos3 = 2;
10268 break;
10269
10270 case 13400: hash_type = HASH_TYPE_AES;
10271 salt_type = SALT_TYPE_EMBEDDED;
10272 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10273 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10274 kern_type = KERN_TYPE_KEEPASS;
10275 dgst_size = DGST_SIZE_4_4;
10276 parse_func = keepass_parse_hash;
10277 sort_by_digest = sort_by_digest_4_4;
10278 opti_type = OPTI_TYPE_ZERO_BYTE;
10279 dgst_pos0 = 0;
10280 dgst_pos1 = 1;
10281 dgst_pos2 = 2;
10282 dgst_pos3 = 3;
10283 break;
10284
10285 default: usage_mini_print (PROGNAME); return (-1);
10286 }
10287
10288 /**
10289 * parser
10290 */
10291
10292 data.parse_func = parse_func;
10293
10294 /**
10295 * misc stuff
10296 */
10297
10298 if (hex_salt)
10299 {
10300 if (salt_type == SALT_TYPE_INTERN)
10301 {
10302 opts_type |= OPTS_TYPE_ST_HEX;
10303 }
10304 else
10305 {
10306 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10307
10308 return (-1);
10309 }
10310 }
10311
10312 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10313 | (salt_type == SALT_TYPE_EXTERN)
10314 | (salt_type == SALT_TYPE_EMBEDDED)
10315 | (salt_type == SALT_TYPE_VIRTUAL));
10316
10317 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10318
10319 data.hash_type = hash_type;
10320 data.attack_mode = attack_mode;
10321 data.attack_kern = attack_kern;
10322 data.attack_exec = attack_exec;
10323 data.kern_type = kern_type;
10324 data.opts_type = opts_type;
10325 data.dgst_size = dgst_size;
10326 data.salt_type = salt_type;
10327 data.isSalted = isSalted;
10328 data.sort_by_digest = sort_by_digest;
10329 data.dgst_pos0 = dgst_pos0;
10330 data.dgst_pos1 = dgst_pos1;
10331 data.dgst_pos2 = dgst_pos2;
10332 data.dgst_pos3 = dgst_pos3;
10333
10334 esalt_size = 0;
10335
10336 switch (hash_mode)
10337 {
10338 case 2500: esalt_size = sizeof (wpa_t); break;
10339 case 5300: esalt_size = sizeof (ikepsk_t); break;
10340 case 5400: esalt_size = sizeof (ikepsk_t); break;
10341 case 5500: esalt_size = sizeof (netntlm_t); break;
10342 case 5600: esalt_size = sizeof (netntlm_t); break;
10343 case 6211: esalt_size = sizeof (tc_t); break;
10344 case 6212: esalt_size = sizeof (tc_t); break;
10345 case 6213: esalt_size = sizeof (tc_t); break;
10346 case 6221: esalt_size = sizeof (tc_t); break;
10347 case 6222: esalt_size = sizeof (tc_t); break;
10348 case 6223: esalt_size = sizeof (tc_t); break;
10349 case 6231: esalt_size = sizeof (tc_t); break;
10350 case 6232: esalt_size = sizeof (tc_t); break;
10351 case 6233: esalt_size = sizeof (tc_t); break;
10352 case 6241: esalt_size = sizeof (tc_t); break;
10353 case 6242: esalt_size = sizeof (tc_t); break;
10354 case 6243: esalt_size = sizeof (tc_t); break;
10355 case 6600: esalt_size = sizeof (agilekey_t); break;
10356 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10357 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10358 case 7300: esalt_size = sizeof (rakp_t); break;
10359 case 7500: esalt_size = sizeof (krb5pa_t); break;
10360 case 8200: esalt_size = sizeof (cloudkey_t); break;
10361 case 8800: esalt_size = sizeof (androidfde_t); break;
10362 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10363 case 9400: esalt_size = sizeof (office2007_t); break;
10364 case 9500: esalt_size = sizeof (office2010_t); break;
10365 case 9600: esalt_size = sizeof (office2013_t); break;
10366 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10367 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10368 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10369 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10370 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10371 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10372 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10373 case 10200: esalt_size = sizeof (cram_md5_t); break;
10374 case 10400: esalt_size = sizeof (pdf_t); break;
10375 case 10410: esalt_size = sizeof (pdf_t); break;
10376 case 10420: esalt_size = sizeof (pdf_t); break;
10377 case 10500: esalt_size = sizeof (pdf_t); break;
10378 case 10600: esalt_size = sizeof (pdf_t); break;
10379 case 10700: esalt_size = sizeof (pdf_t); break;
10380 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10381 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10382 case 11400: esalt_size = sizeof (sip_t); break;
10383 case 11600: esalt_size = sizeof (seven_zip_t); break;
10384 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10385 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10386 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10387 case 13000: esalt_size = sizeof (rar5_t); break;
10388 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10389 case 13400: esalt_size = sizeof (keepass_t); break;
10390 }
10391
10392 data.esalt_size = esalt_size;
10393
10394 /**
10395 * choose dictionary parser
10396 */
10397
10398 if (hash_type == HASH_TYPE_LM)
10399 {
10400 get_next_word_func = get_next_word_lm;
10401 }
10402 else if (opts_type & OPTS_TYPE_PT_UPPER)
10403 {
10404 get_next_word_func = get_next_word_uc;
10405 }
10406 else
10407 {
10408 get_next_word_func = get_next_word_std;
10409 }
10410
10411 /**
10412 * dictstat
10413 */
10414
10415 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10416
10417 #ifdef _POSIX
10418 size_t dictstat_nmemb = 0;
10419 #endif
10420
10421 #ifdef _WIN
10422 uint dictstat_nmemb = 0;
10423 #endif
10424
10425 char dictstat[256] = { 0 };
10426
10427 FILE *dictstat_fp = NULL;
10428
10429 if (keyspace == 0)
10430 {
10431 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
10432
10433 dictstat_fp = fopen (dictstat, "rb");
10434
10435 if (dictstat_fp)
10436 {
10437 #ifdef _POSIX
10438 struct stat tmpstat;
10439
10440 fstat (fileno (dictstat_fp), &tmpstat);
10441 #endif
10442
10443 #ifdef _WIN
10444 struct stat64 tmpstat;
10445
10446 _fstat64 (fileno (dictstat_fp), &tmpstat);
10447 #endif
10448
10449 if (tmpstat.st_mtime < COMPTIME)
10450 {
10451 /* with v0.15 the format changed so we have to ensure user is using a good version
10452 since there is no version-header in the dictstat file */
10453
10454 fclose (dictstat_fp);
10455
10456 unlink (dictstat);
10457 }
10458 else
10459 {
10460 while (!feof (dictstat_fp))
10461 {
10462 dictstat_t d;
10463
10464 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10465
10466 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10467
10468 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10469 {
10470 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10471
10472 return -1;
10473 }
10474 }
10475
10476 fclose (dictstat_fp);
10477 }
10478 }
10479 }
10480
10481 /**
10482 * potfile
10483 */
10484
10485 char potfile[256] = { 0 };
10486
10487 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
10488
10489 data.pot_fp = NULL;
10490
10491 FILE *out_fp = NULL;
10492 FILE *pot_fp = NULL;
10493
10494 if (show == 1 || left == 1)
10495 {
10496 pot_fp = fopen (potfile, "rb");
10497
10498 if (pot_fp == NULL)
10499 {
10500 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10501
10502 return (-1);
10503 }
10504
10505 if (outfile != NULL)
10506 {
10507 if ((out_fp = fopen (outfile, "ab")) == NULL)
10508 {
10509 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10510
10511 fclose (pot_fp);
10512
10513 return (-1);
10514 }
10515 }
10516 else
10517 {
10518 out_fp = stdout;
10519 }
10520 }
10521 else
10522 {
10523 if (potfile_disable == 0)
10524 {
10525 pot_fp = fopen (potfile, "ab");
10526
10527 if (pot_fp == NULL)
10528 {
10529 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10530
10531 return (-1);
10532 }
10533
10534 data.pot_fp = pot_fp;
10535 }
10536 }
10537
10538 pot_t *pot = NULL;
10539
10540 uint pot_cnt = 0;
10541 uint pot_avail = 0;
10542
10543 if (show == 1 || left == 1)
10544 {
10545 SUPPRESS_OUTPUT = 1;
10546
10547 pot_avail = count_lines (pot_fp);
10548
10549 rewind (pot_fp);
10550
10551 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10552
10553 uint pot_hashes_avail = 0;
10554
10555 uint line_num = 0;
10556
10557 char *line_buf = (char *) mymalloc (HCBUFSIZ);
10558
10559 while (!feof (pot_fp))
10560 {
10561 line_num++;
10562
10563 int line_len = fgetl (pot_fp, line_buf);
10564
10565 if (line_len == 0) continue;
10566
10567 char *plain_buf = line_buf + line_len;
10568
10569 pot_t *pot_ptr = &pot[pot_cnt];
10570
10571 hash_t *hashes_buf = &pot_ptr->hash;
10572
10573 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10574 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10575
10576 if (pot_cnt == pot_hashes_avail)
10577 {
10578 uint pos = 0;
10579
10580 for (pos = 0; pos < INCR_POT; pos++)
10581 {
10582 if ((pot_cnt + pos) >= pot_avail) break;
10583
10584 pot_t *tmp_pot = &pot[pot_cnt + pos];
10585
10586 hash_t *tmp_hash = &tmp_pot->hash;
10587
10588 tmp_hash->digest = mymalloc (dgst_size);
10589
10590 if (isSalted)
10591 {
10592 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10593 }
10594
10595 if (esalt_size)
10596 {
10597 tmp_hash->esalt = mymalloc (esalt_size);
10598 }
10599
10600 pot_hashes_avail++;
10601 }
10602 }
10603
10604 int plain_len = 0;
10605
10606 int parser_status;
10607
10608 int iter = MAX_CUT_TRIES;
10609
10610 do
10611 {
10612 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10613 {
10614 if (line_buf[i] == ':')
10615 {
10616 line_len--;
10617
10618 break;
10619 }
10620 }
10621
10622 if (data.hash_mode != 2500)
10623 {
10624 parser_status = parse_func (line_buf, line_len, hashes_buf);
10625 }
10626 else
10627 {
10628 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10629
10630 if (line_len > max_salt_size)
10631 {
10632 parser_status = PARSER_GLOBAL_LENGTH;
10633 }
10634 else
10635 {
10636 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10637
10638 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10639
10640 hashes_buf->salt->salt_len = line_len;
10641
10642 parser_status = PARSER_OK;
10643 }
10644 }
10645
10646 // if NOT parsed without error, we add the ":" to the plain
10647
10648 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10649 {
10650 plain_len++;
10651 plain_buf--;
10652 }
10653
10654 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10655
10656 if (parser_status < PARSER_GLOBAL_ZERO)
10657 {
10658 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10659
10660 continue;
10661 }
10662
10663 if (plain_len >= 255) continue;
10664
10665 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10666
10667 pot_ptr->plain_len = plain_len;
10668
10669 pot_cnt++;
10670 }
10671
10672 myfree (line_buf);
10673
10674 fclose (pot_fp);
10675
10676 SUPPRESS_OUTPUT = 0;
10677
10678 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10679 }
10680
10681 /**
10682 * word len
10683 */
10684
10685 uint pw_min = PW_MIN;
10686 uint pw_max = PW_MAX;
10687
10688 switch (hash_mode)
10689 {
10690 case 125: if (pw_max > 32) pw_max = 32;
10691 break;
10692 case 400: if (pw_max > 40) pw_max = 40;
10693 break;
10694 case 500: if (pw_max > 16) pw_max = 16;
10695 break;
10696 case 1500: if (pw_max > 8) pw_max = 8;
10697 break;
10698 case 1600: if (pw_max > 16) pw_max = 16;
10699 break;
10700 case 1800: if (pw_max > 16) pw_max = 16;
10701 break;
10702 case 2100: if (pw_max > 16) pw_max = 16;
10703 break;
10704 case 2500: if (pw_min < 8) pw_min = 8;
10705 break;
10706 case 3000: if (pw_max > 7) pw_max = 7;
10707 break;
10708 case 5200: if (pw_max > 24) pw_max = 24;
10709 break;
10710 case 5800: if (pw_max > 16) pw_max = 16;
10711 break;
10712 case 6300: if (pw_max > 16) pw_max = 16;
10713 break;
10714 case 7400: if (pw_max > 16) pw_max = 16;
10715 break;
10716 case 7900: if (pw_max > 48) pw_max = 48;
10717 break;
10718 case 8500: if (pw_max > 8) pw_max = 8;
10719 break;
10720 case 8600: if (pw_max > 16) pw_max = 16;
10721 break;
10722 case 9710: pw_min = 5;
10723 pw_max = 5;
10724 break;
10725 case 9810: pw_min = 5;
10726 pw_max = 5;
10727 break;
10728 case 10410: pw_min = 5;
10729 pw_max = 5;
10730 break;
10731 case 10300: if (pw_max < 3) pw_min = 3;
10732 if (pw_max > 40) pw_max = 40;
10733 break;
10734 case 10500: if (pw_max < 3) pw_min = 3;
10735 if (pw_max > 40) pw_max = 40;
10736 break;
10737 case 10700: if (pw_max > 16) pw_max = 16;
10738 break;
10739 case 11300: if (pw_max > 40) pw_max = 40;
10740 break;
10741 case 12500: if (pw_max > 20) pw_max = 20;
10742 break;
10743 case 12800: if (pw_max > 24) pw_max = 24;
10744 break;
10745 }
10746
10747 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10748 {
10749 switch (attack_kern)
10750 {
10751 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10752 break;
10753 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10754 break;
10755 }
10756 }
10757
10758 /**
10759 * charsets : keep them together for more easy maintainnce
10760 */
10761
10762 cs_t mp_sys[6] = { { { 0 }, 0 } };
10763 cs_t mp_usr[4] = { { { 0 }, 0 } };
10764
10765 mp_setup_sys (mp_sys);
10766
10767 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10768 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10769 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10770 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10771
10772 /**
10773 * load hashes, part I: find input mode, count hashes
10774 */
10775
10776 uint hashlist_mode = 0;
10777 uint hashlist_format = HLFMT_HASHCAT;
10778
10779 uint hashes_avail = 0;
10780
10781 if (benchmark == 0)
10782 {
10783 struct stat f;
10784
10785 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10786
10787 if ((hash_mode == 2500) ||
10788 (hash_mode == 5200) ||
10789 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10790 (hash_mode == 9000))
10791 {
10792 hashlist_mode = HL_MODE_ARG;
10793
10794 char *hashfile = myargv[optind];
10795
10796 data.hashfile = hashfile;
10797
10798 logfile_top_var_string ("target", hashfile);
10799 }
10800
10801 if (hashlist_mode == HL_MODE_ARG)
10802 {
10803 if (hash_mode == 2500)
10804 {
10805 struct stat st;
10806
10807 if (stat (data.hashfile, &st) == -1)
10808 {
10809 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10810
10811 return (-1);
10812 }
10813
10814 hashes_avail = st.st_size / sizeof (hccap_t);
10815 }
10816 else
10817 {
10818 hashes_avail = 1;
10819 }
10820 }
10821 else if (hashlist_mode == HL_MODE_FILE)
10822 {
10823 char *hashfile = myargv[optind];
10824
10825 data.hashfile = hashfile;
10826
10827 logfile_top_var_string ("target", hashfile);
10828
10829 FILE *fp = NULL;
10830
10831 if ((fp = fopen (hashfile, "rb")) == NULL)
10832 {
10833 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10834
10835 return (-1);
10836 }
10837
10838 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10839
10840 hashes_avail = count_lines (fp);
10841
10842 rewind (fp);
10843
10844 if (hashes_avail == 0)
10845 {
10846 log_error ("ERROR: hashfile is empty or corrupt");
10847
10848 fclose (fp);
10849
10850 return (-1);
10851 }
10852
10853 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10854
10855 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10856 {
10857 log_error ("ERROR: remove not supported in native hashfile-format mode");
10858
10859 fclose (fp);
10860
10861 return (-1);
10862 }
10863
10864 fclose (fp);
10865 }
10866 }
10867 else
10868 {
10869 hashlist_mode = HL_MODE_ARG;
10870
10871 hashes_avail = 1;
10872 }
10873
10874 if (hash_mode == 3000) hashes_avail *= 2;
10875
10876 data.hashlist_mode = hashlist_mode;
10877 data.hashlist_format = hashlist_format;
10878
10879 logfile_top_uint (hashlist_mode);
10880 logfile_top_uint (hashlist_format);
10881
10882 /**
10883 * load hashes, part II: allocate required memory, set pointers
10884 */
10885
10886 hash_t *hashes_buf = NULL;
10887 void *digests_buf = NULL;
10888 salt_t *salts_buf = NULL;
10889 void *esalts_buf = NULL;
10890
10891 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10892
10893 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10894
10895 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10896 {
10897 u32 hash_pos;
10898
10899 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10900 {
10901 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10902
10903 hashes_buf[hash_pos].hash_info = hash_info;
10904
10905 if (username && (remove || show || left))
10906 {
10907 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10908 }
10909
10910 if (benchmark)
10911 {
10912 hash_info->orighash = (char *) mymalloc (256);
10913 }
10914 }
10915 }
10916
10917 if (isSalted)
10918 {
10919 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10920
10921 if (esalt_size)
10922 {
10923 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10924 }
10925 }
10926 else
10927 {
10928 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10929 }
10930
10931 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10932 {
10933 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10934
10935 if (isSalted)
10936 {
10937 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10938
10939 if (esalt_size)
10940 {
10941 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10942 }
10943 }
10944 else
10945 {
10946 hashes_buf[hash_pos].salt = &salts_buf[0];
10947 }
10948 }
10949
10950 /**
10951 * load hashes, part III: parse hashes or generate them if benchmark
10952 */
10953
10954 uint hashes_cnt = 0;
10955
10956 if (benchmark == 0)
10957 {
10958 if (keyspace == 1)
10959 {
10960 // useless to read hash file for keyspace, cheat a little bit w/ optind
10961 }
10962 else if (hashes_avail == 0)
10963 {
10964 }
10965 else if (hashlist_mode == HL_MODE_ARG)
10966 {
10967 char *input_buf = myargv[optind];
10968
10969 uint input_len = strlen (input_buf);
10970
10971 logfile_top_var_string ("target", input_buf);
10972
10973 char *hash_buf = NULL;
10974 int hash_len = 0;
10975
10976 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10977
10978 bool hash_fmt_error = 0;
10979
10980 if (hash_len < 1) hash_fmt_error = 1;
10981 if (hash_buf == NULL) hash_fmt_error = 1;
10982
10983 if (hash_fmt_error)
10984 {
10985 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
10986 }
10987 else
10988 {
10989 if (opts_type & OPTS_TYPE_HASH_COPY)
10990 {
10991 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10992
10993 hash_info_tmp->orighash = mystrdup (hash_buf);
10994 }
10995
10996 if (isSalted)
10997 {
10998 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
10999 }
11000
11001 int parser_status = PARSER_OK;
11002
11003 if (hash_mode == 2500)
11004 {
11005 if (hash_len == 0)
11006 {
11007 log_error ("ERROR: hccap file not specified");
11008
11009 return (-1);
11010 }
11011
11012 hashlist_mode = HL_MODE_FILE;
11013
11014 data.hashlist_mode = hashlist_mode;
11015
11016 FILE *fp = fopen (hash_buf, "rb");
11017
11018 if (fp == NULL)
11019 {
11020 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11021
11022 return (-1);
11023 }
11024
11025 if (hashes_avail < 1)
11026 {
11027 log_error ("ERROR: hccap file is empty or corrupt");
11028
11029 fclose (fp);
11030
11031 return (-1);
11032 }
11033
11034 uint hccap_size = sizeof (hccap_t);
11035
11036 char *in = (char *) mymalloc (hccap_size);
11037
11038 while (!feof (fp))
11039 {
11040 int n = fread (in, hccap_size, 1, fp);
11041
11042 if (n != 1)
11043 {
11044 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11045
11046 break;
11047 }
11048
11049 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11050
11051 if (parser_status != PARSER_OK)
11052 {
11053 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11054
11055 continue;
11056 }
11057
11058 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11059
11060 if ((show == 1) || (left == 1))
11061 {
11062 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11063
11064 char *salt_ptr = (char *) tmp_salt->salt_buf;
11065
11066 int cur_pos = tmp_salt->salt_len;
11067 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11068
11069 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11070
11071 // do the appending task
11072
11073 snprintf (salt_ptr + cur_pos,
11074 rem_len,
11075 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11076 wpa->orig_mac1[0],
11077 wpa->orig_mac1[1],
11078 wpa->orig_mac1[2],
11079 wpa->orig_mac1[3],
11080 wpa->orig_mac1[4],
11081 wpa->orig_mac1[5],
11082 wpa->orig_mac2[0],
11083 wpa->orig_mac2[1],
11084 wpa->orig_mac2[2],
11085 wpa->orig_mac2[3],
11086 wpa->orig_mac2[4],
11087 wpa->orig_mac2[5]);
11088
11089 // memset () the remaining part of the salt
11090
11091 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11092 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11093
11094 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11095
11096 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11097 }
11098
11099 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);
11100 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);
11101
11102 hashes_cnt++;
11103 }
11104
11105 fclose (fp);
11106
11107 myfree (in);
11108 }
11109 else if (hash_mode == 3000)
11110 {
11111 if (hash_len == 32)
11112 {
11113 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11114
11115 hash_t *lm_hash_left = NULL;
11116
11117 if (parser_status == PARSER_OK)
11118 {
11119 lm_hash_left = &hashes_buf[hashes_cnt];
11120
11121 hashes_cnt++;
11122 }
11123 else
11124 {
11125 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11126 }
11127
11128 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11129
11130 hash_t *lm_hash_right = NULL;
11131
11132 if (parser_status == PARSER_OK)
11133 {
11134 lm_hash_right = &hashes_buf[hashes_cnt];
11135
11136 hashes_cnt++;
11137 }
11138 else
11139 {
11140 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11141 }
11142
11143 // show / left
11144
11145 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11146 {
11147 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);
11148 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);
11149 }
11150 }
11151 else
11152 {
11153 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11154
11155 if (parser_status == PARSER_OK)
11156 {
11157 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11158 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11159 }
11160
11161 if (parser_status == PARSER_OK)
11162 {
11163 hashes_cnt++;
11164 }
11165 else
11166 {
11167 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11168 }
11169 }
11170 }
11171 else
11172 {
11173 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11174
11175 if (parser_status == PARSER_OK)
11176 {
11177 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11178 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11179 }
11180
11181 if (parser_status == PARSER_OK)
11182 {
11183 hashes_cnt++;
11184 }
11185 else
11186 {
11187 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11188 }
11189 }
11190 }
11191 }
11192 else if (hashlist_mode == HL_MODE_FILE)
11193 {
11194 char *hashfile = data.hashfile;
11195
11196 FILE *fp;
11197
11198 if ((fp = fopen (hashfile, "rb")) == NULL)
11199 {
11200 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11201
11202 return (-1);
11203 }
11204
11205 uint line_num = 0;
11206
11207 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11208
11209 while (!feof (fp))
11210 {
11211 line_num++;
11212
11213 int line_len = fgetl (fp, line_buf);
11214
11215 if (line_len == 0) continue;
11216
11217 char *hash_buf = NULL;
11218 int hash_len = 0;
11219
11220 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11221
11222 bool hash_fmt_error = 0;
11223
11224 if (hash_len < 1) hash_fmt_error = 1;
11225 if (hash_buf == NULL) hash_fmt_error = 1;
11226
11227 if (hash_fmt_error)
11228 {
11229 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11230
11231 continue;
11232 }
11233
11234 if (username)
11235 {
11236 char *user_buf = NULL;
11237 int user_len = 0;
11238
11239 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11240
11241 if (remove || show)
11242 {
11243 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11244
11245 *user = (user_t *) mymalloc (sizeof (user_t));
11246
11247 user_t *user_ptr = *user;
11248
11249 if (user_buf != NULL)
11250 {
11251 user_ptr->user_name = mystrdup (user_buf);
11252 }
11253 else
11254 {
11255 user_ptr->user_name = mystrdup ("");
11256 }
11257
11258 user_ptr->user_len = user_len;
11259 }
11260 }
11261
11262 if (opts_type & OPTS_TYPE_HASH_COPY)
11263 {
11264 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11265
11266 hash_info_tmp->orighash = mystrdup (hash_buf);
11267 }
11268
11269 if (isSalted)
11270 {
11271 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11272 }
11273
11274 if (hash_mode == 3000)
11275 {
11276 if (hash_len == 32)
11277 {
11278 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11279
11280 if (parser_status < PARSER_GLOBAL_ZERO)
11281 {
11282 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11283
11284 continue;
11285 }
11286
11287 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11288
11289 hashes_cnt++;
11290
11291 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11292
11293 if (parser_status < PARSER_GLOBAL_ZERO)
11294 {
11295 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11296
11297 continue;
11298 }
11299
11300 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11301
11302 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);
11303
11304 hashes_cnt++;
11305
11306 // show / left
11307
11308 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);
11309 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);
11310 }
11311 else
11312 {
11313 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11314
11315 if (parser_status < PARSER_GLOBAL_ZERO)
11316 {
11317 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11318
11319 continue;
11320 }
11321
11322 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);
11323
11324 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11325 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11326
11327 hashes_cnt++;
11328 }
11329 }
11330 else
11331 {
11332 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11333
11334 if (parser_status < PARSER_GLOBAL_ZERO)
11335 {
11336 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11337
11338 continue;
11339 }
11340
11341 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);
11342
11343 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11344 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11345
11346 hashes_cnt++;
11347 }
11348 }
11349
11350 myfree (line_buf);
11351
11352 fclose (fp);
11353
11354 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11355
11356 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11357 }
11358 }
11359 else
11360 {
11361 if (isSalted)
11362 {
11363 hashes_buf[0].salt->salt_len = 8;
11364
11365 // special salt handling
11366
11367 switch (hash_mode)
11368 {
11369 case 1500: hashes_buf[0].salt->salt_len = 2;
11370 break;
11371 case 1731: hashes_buf[0].salt->salt_len = 4;
11372 break;
11373 case 2410: hashes_buf[0].salt->salt_len = 4;
11374 break;
11375 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11376 break;
11377 case 3100: hashes_buf[0].salt->salt_len = 1;
11378 break;
11379 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11380 break;
11381 case 5800: hashes_buf[0].salt->salt_len = 16;
11382 break;
11383 case 6800: hashes_buf[0].salt->salt_len = 32;
11384 break;
11385 case 8400: hashes_buf[0].salt->salt_len = 40;
11386 break;
11387 case 8800: hashes_buf[0].salt->salt_len = 16;
11388 break;
11389 case 8900: hashes_buf[0].salt->salt_len = 16;
11390 hashes_buf[0].salt->scrypt_N = 1024;
11391 hashes_buf[0].salt->scrypt_r = 1;
11392 hashes_buf[0].salt->scrypt_p = 1;
11393 break;
11394 case 9100: hashes_buf[0].salt->salt_len = 16;
11395 break;
11396 case 9300: hashes_buf[0].salt->salt_len = 14;
11397 hashes_buf[0].salt->scrypt_N = 16384;
11398 hashes_buf[0].salt->scrypt_r = 1;
11399 hashes_buf[0].salt->scrypt_p = 1;
11400 break;
11401 case 9400: hashes_buf[0].salt->salt_len = 16;
11402 break;
11403 case 9500: hashes_buf[0].salt->salt_len = 16;
11404 break;
11405 case 9600: hashes_buf[0].salt->salt_len = 16;
11406 break;
11407 case 9700: hashes_buf[0].salt->salt_len = 16;
11408 break;
11409 case 9710: hashes_buf[0].salt->salt_len = 16;
11410 break;
11411 case 9720: hashes_buf[0].salt->salt_len = 16;
11412 break;
11413 case 9800: hashes_buf[0].salt->salt_len = 16;
11414 break;
11415 case 9810: hashes_buf[0].salt->salt_len = 16;
11416 break;
11417 case 9820: hashes_buf[0].salt->salt_len = 16;
11418 break;
11419 case 10300: hashes_buf[0].salt->salt_len = 12;
11420 break;
11421 case 11500: hashes_buf[0].salt->salt_len = 4;
11422 break;
11423 case 11600: hashes_buf[0].salt->salt_len = 4;
11424 break;
11425 case 12400: hashes_buf[0].salt->salt_len = 4;
11426 break;
11427 case 12500: hashes_buf[0].salt->salt_len = 8;
11428 break;
11429 case 12600: hashes_buf[0].salt->salt_len = 64;
11430 break;
11431 }
11432
11433 // special esalt handling
11434
11435 switch (hash_mode)
11436 {
11437 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11438 break;
11439 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11440 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11441 break;
11442 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11443 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11444 break;
11445 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11446 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11447 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11448 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11449 break;
11450 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11451 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11452 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11453 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11454 break;
11455 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11456 break;
11457 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11458 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11459 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11460 break;
11461 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11462 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11463 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11464 break;
11465 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11466 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11467 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11468 break;
11469 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11470 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11471 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11472 break;
11473 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11474 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11475 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11476 break;
11477 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11478 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11479 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11480 break;
11481 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11482 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11483 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11484 break;
11485 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
11486 break;
11487 }
11488 }
11489
11490 // set hashfile
11491
11492 switch (hash_mode)
11493 {
11494 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11495 break;
11496 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11497 break;
11498 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11499 break;
11500 case 6211: data.hashfile = mystrdup ("hashcat.tc");
11501 break;
11502 case 6212: data.hashfile = mystrdup ("hashcat.tc");
11503 break;
11504 case 6213: data.hashfile = mystrdup ("hashcat.tc");
11505 break;
11506 case 6221: data.hashfile = mystrdup ("hashcat.tc");
11507 break;
11508 case 6222: data.hashfile = mystrdup ("hashcat.tc");
11509 break;
11510 case 6223: data.hashfile = mystrdup ("hashcat.tc");
11511 break;
11512 case 6231: data.hashfile = mystrdup ("hashcat.tc");
11513 break;
11514 case 6232: data.hashfile = mystrdup ("hashcat.tc");
11515 break;
11516 case 6233: data.hashfile = mystrdup ("hashcat.tc");
11517 break;
11518 case 6241: data.hashfile = mystrdup ("hashcat.tc");
11519 break;
11520 case 6242: data.hashfile = mystrdup ("hashcat.tc");
11521 break;
11522 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11523 break;
11524 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11525 break;
11526 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11527 break;
11528 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11529 break;
11530 }
11531
11532 // set default iterations
11533
11534 switch (hash_mode)
11535 {
11536 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11537 break;
11538 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11539 break;
11540 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11541 break;
11542 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11543 break;
11544 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11545 break;
11546 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11547 break;
11548 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11549 break;
11550 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11551 break;
11552 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11553 break;
11554 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11555 break;
11556 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11557 break;
11558 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11559 break;
11560 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11561 break;
11562 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11563 break;
11564 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11565 break;
11566 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11567 break;
11568 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11569 break;
11570 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11571 break;
11572 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11573 break;
11574 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11575 break;
11576 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11577 break;
11578 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11579 break;
11580 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11581 break;
11582 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11583 break;
11584 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11585 break;
11586 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11587 break;
11588 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11589 break;
11590 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11591 break;
11592 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11593 break;
11594 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11595 break;
11596 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11597 break;
11598 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11599 break;
11600 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11601 break;
11602 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11603 break;
11604 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11605 break;
11606 case 8900: hashes_buf[0].salt->salt_iter = 1;
11607 break;
11608 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11609 break;
11610 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11611 break;
11612 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11613 break;
11614 case 9300: hashes_buf[0].salt->salt_iter = 1;
11615 break;
11616 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11617 break;
11618 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11619 break;
11620 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11621 break;
11622 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11623 break;
11624 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11625 break;
11626 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11627 break;
11628 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11629 break;
11630 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11631 break;
11632 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11633 break;
11634 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11635 break;
11636 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11637 break;
11638 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11639 break;
11640 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11641 break;
11642 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11643 break;
11644 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11645 break;
11646 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11647 break;
11648 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11649 break;
11650 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11651 break;
11652 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11653 break;
11654 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11655 break;
11656 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11657 break;
11658 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
11659 break;
11660 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
11661 break;
11662 }
11663
11664 hashes_cnt = 1;
11665 }
11666
11667 if (show == 1 || left == 1)
11668 {
11669 for (uint i = 0; i < pot_cnt; i++)
11670 {
11671 pot_t *pot_ptr = &pot[i];
11672
11673 hash_t *hashes_buf = &pot_ptr->hash;
11674
11675 local_free (hashes_buf->digest);
11676
11677 if (isSalted)
11678 {
11679 local_free (hashes_buf->salt);
11680 }
11681 }
11682
11683 local_free (pot);
11684
11685 if (data.quiet == 0) log_info_nn ("");
11686
11687 return (0);
11688 }
11689
11690 if (keyspace == 0)
11691 {
11692 if (hashes_cnt == 0)
11693 {
11694 log_error ("ERROR: No hashes loaded");
11695
11696 return (-1);
11697 }
11698 }
11699
11700 /**
11701 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11702 */
11703
11704 if (data.outfile != NULL)
11705 {
11706 if (data.hashfile != NULL)
11707 {
11708 #ifdef _POSIX
11709 struct stat tmpstat_outfile;
11710 struct stat tmpstat_hashfile;
11711 #endif
11712
11713 #ifdef _WIN
11714 struct stat64 tmpstat_outfile;
11715 struct stat64 tmpstat_hashfile;
11716 #endif
11717
11718 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11719
11720 if (tmp_outfile_fp)
11721 {
11722 #ifdef _POSIX
11723 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11724 #endif
11725
11726 #ifdef _WIN
11727 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11728 #endif
11729
11730 fclose (tmp_outfile_fp);
11731 }
11732
11733 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11734
11735 if (tmp_hashfile_fp)
11736 {
11737 #ifdef _POSIX
11738 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11739 #endif
11740
11741 #ifdef _WIN
11742 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11743 #endif
11744
11745 fclose (tmp_hashfile_fp);
11746 }
11747
11748 if (tmp_outfile_fp && tmp_outfile_fp)
11749 {
11750 tmpstat_outfile.st_mode = 0;
11751 tmpstat_outfile.st_nlink = 0;
11752 tmpstat_outfile.st_uid = 0;
11753 tmpstat_outfile.st_gid = 0;
11754 tmpstat_outfile.st_rdev = 0;
11755 tmpstat_outfile.st_atime = 0;
11756
11757 tmpstat_hashfile.st_mode = 0;
11758 tmpstat_hashfile.st_nlink = 0;
11759 tmpstat_hashfile.st_uid = 0;
11760 tmpstat_hashfile.st_gid = 0;
11761 tmpstat_hashfile.st_rdev = 0;
11762 tmpstat_hashfile.st_atime = 0;
11763
11764 #ifdef _POSIX
11765 tmpstat_outfile.st_blksize = 0;
11766 tmpstat_outfile.st_blocks = 0;
11767
11768 tmpstat_hashfile.st_blksize = 0;
11769 tmpstat_hashfile.st_blocks = 0;
11770 #endif
11771
11772 #ifdef _POSIX
11773 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11774 {
11775 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11776
11777 return (-1);
11778 }
11779 #endif
11780
11781 #ifdef _WIN
11782 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11783 {
11784 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11785
11786 return (-1);
11787 }
11788 #endif
11789 }
11790 }
11791 }
11792
11793 /**
11794 * Remove duplicates
11795 */
11796
11797 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11798
11799 if (isSalted)
11800 {
11801 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11802 }
11803 else
11804 {
11805 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11806 }
11807
11808 uint hashes_cnt_orig = hashes_cnt;
11809
11810 hashes_cnt = 1;
11811
11812 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11813 {
11814 if (isSalted)
11815 {
11816 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11817 {
11818 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11819 }
11820 }
11821 else
11822 {
11823 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11824 }
11825
11826 if (hashes_pos > hashes_cnt)
11827 {
11828 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11829 }
11830
11831 hashes_cnt++;
11832 }
11833
11834 /**
11835 * Potfile removes
11836 */
11837
11838 uint potfile_remove_cracks = 0;
11839
11840 if (potfile_disable == 0)
11841 {
11842 hash_t hash_buf;
11843
11844 hash_buf.digest = mymalloc (dgst_size);
11845 hash_buf.salt = NULL;
11846 hash_buf.esalt = NULL;
11847 hash_buf.hash_info = NULL;
11848 hash_buf.cracked = 0;
11849
11850 if (isSalted)
11851 {
11852 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11853 }
11854
11855 if (esalt_size)
11856 {
11857 hash_buf.esalt = mymalloc (esalt_size);
11858 }
11859
11860 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11861
11862 // no solution for these special hash types (for instane because they use hashfile in output etc)
11863 if ((hash_mode != 5200) &&
11864 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11865 (hash_mode != 9000))
11866 {
11867 FILE *fp = fopen (potfile, "rb");
11868
11869 if (fp != NULL)
11870 {
11871 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11872
11873 // to be safe work with a copy (because of line_len loop, i etc)
11874 // moved up here because it's easier to handle continue case
11875 // it's just 64kb
11876
11877 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
11878
11879 while (!feof (fp))
11880 {
11881 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
11882
11883 if (ptr == NULL) break;
11884
11885 int line_len = strlen (line_buf);
11886
11887 if (line_len == 0) continue;
11888
11889 int iter = MAX_CUT_TRIES;
11890
11891 for (int i = line_len - 1; i && iter; i--, line_len--)
11892 {
11893 if (line_buf[i] != ':') continue;
11894
11895 if (isSalted)
11896 {
11897 memset (hash_buf.salt, 0, sizeof (salt_t));
11898 }
11899
11900 hash_t *found = NULL;
11901
11902 if (hash_mode == 6800)
11903 {
11904 if (i < 64) // 64 = 16 * uint in salt_buf[]
11905 {
11906 // manipulate salt_buf
11907 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11908
11909 hash_buf.salt->salt_len = i;
11910
11911 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11912 }
11913 }
11914 else if (hash_mode == 2500)
11915 {
11916 if (i < 64) // 64 = 16 * uint in salt_buf[]
11917 {
11918 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11919 // manipulate salt_buf
11920
11921 memcpy (line_buf_cpy, line_buf, i);
11922
11923 char *mac2_pos = strrchr (line_buf_cpy, ':');
11924
11925 if (mac2_pos == NULL) continue;
11926
11927 mac2_pos[0] = 0;
11928 mac2_pos++;
11929
11930 if (strlen (mac2_pos) != 12) continue;
11931
11932 char *mac1_pos = strrchr (line_buf_cpy, ':');
11933
11934 if (mac1_pos == NULL) continue;
11935
11936 mac1_pos[0] = 0;
11937 mac1_pos++;
11938
11939 if (strlen (mac1_pos) != 12) continue;
11940
11941 uint essid_length = mac1_pos - line_buf_cpy - 1;
11942
11943 // here we need the ESSID
11944 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11945
11946 hash_buf.salt->salt_len = essid_length;
11947
11948 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11949
11950 if (found)
11951 {
11952 wpa_t *wpa = (wpa_t *) found->esalt;
11953
11954 // compare hex string(s) vs binary MAC address(es)
11955
11956 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11957 {
11958 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
11959 {
11960 found = NULL;
11961
11962 break;
11963 }
11964 }
11965
11966 // early skip ;)
11967 if (!found) continue;
11968
11969 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11970 {
11971 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
11972 {
11973 found = NULL;
11974
11975 break;
11976 }
11977 }
11978 }
11979 }
11980 }
11981 else
11982 {
11983 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
11984
11985 if (parser_status == PARSER_OK)
11986 {
11987 if (isSalted)
11988 {
11989 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11990 }
11991 else
11992 {
11993 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11994 }
11995 }
11996 }
11997
11998 if (found == NULL) continue;
11999
12000 if (!found->cracked) potfile_remove_cracks++;
12001
12002 found->cracked = 1;
12003
12004 if (found) break;
12005
12006 iter--;
12007 }
12008 }
12009
12010 myfree (line_buf_cpy);
12011
12012 myfree (line_buf);
12013
12014 fclose (fp);
12015 }
12016 }
12017
12018 if (esalt_size)
12019 {
12020 local_free (hash_buf.esalt);
12021 }
12022
12023 if (isSalted)
12024 {
12025 local_free (hash_buf.salt);
12026 }
12027
12028 local_free (hash_buf.digest);
12029 }
12030
12031 /**
12032 * Now generate all the buffers required for later
12033 */
12034
12035 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12036
12037 salt_t *salts_buf_new = NULL;
12038 void *esalts_buf_new = NULL;
12039
12040 if (isSalted)
12041 {
12042 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12043
12044 if (esalt_size)
12045 {
12046 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12047 }
12048 }
12049 else
12050 {
12051 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12052 }
12053
12054 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12055
12056 uint digests_cnt = hashes_cnt;
12057 uint digests_done = 0;
12058
12059 uint size_digests = digests_cnt * dgst_size;
12060 uint size_shown = digests_cnt * sizeof (uint);
12061
12062 uint *digests_shown = (uint *) mymalloc (size_shown);
12063 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12064
12065 uint salts_cnt = 0;
12066 uint salts_done = 0;
12067
12068 hashinfo_t **hash_info = NULL;
12069
12070 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12071 {
12072 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12073
12074 if (username && (remove || show))
12075 {
12076 uint user_pos;
12077
12078 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12079 {
12080 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12081
12082 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12083 }
12084 }
12085 }
12086
12087 uint *salts_shown = (uint *) mymalloc (size_shown);
12088
12089 salt_t *salt_buf;
12090
12091 {
12092 // copied from inner loop
12093
12094 salt_buf = &salts_buf_new[salts_cnt];
12095
12096 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12097
12098 if (esalt_size)
12099 {
12100 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12101 }
12102
12103 salt_buf->digests_cnt = 0;
12104 salt_buf->digests_done = 0;
12105 salt_buf->digests_offset = 0;
12106
12107 salts_cnt++;
12108 }
12109
12110 if (hashes_buf[0].cracked == 1)
12111 {
12112 digests_shown[0] = 1;
12113
12114 digests_done++;
12115
12116 salt_buf->digests_done++;
12117 }
12118
12119 salt_buf->digests_cnt++;
12120
12121 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12122
12123 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12124 {
12125 hash_info[0] = hashes_buf[0].hash_info;
12126 }
12127
12128 // copy from inner loop
12129
12130 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12131 {
12132 if (isSalted)
12133 {
12134 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12135 {
12136 salt_buf = &salts_buf_new[salts_cnt];
12137
12138 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12139
12140 if (esalt_size)
12141 {
12142 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12143 }
12144
12145 salt_buf->digests_cnt = 0;
12146 salt_buf->digests_done = 0;
12147 salt_buf->digests_offset = hashes_pos;
12148
12149 salts_cnt++;
12150 }
12151 }
12152
12153 if (hashes_buf[hashes_pos].cracked == 1)
12154 {
12155 digests_shown[hashes_pos] = 1;
12156
12157 digests_done++;
12158
12159 salt_buf->digests_done++;
12160 }
12161
12162 salt_buf->digests_cnt++;
12163
12164 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12165
12166 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12167 {
12168 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12169 }
12170 }
12171
12172 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12173 {
12174 salt_t *salt_buf = &salts_buf_new[salt_pos];
12175
12176 if (salt_buf->digests_done == salt_buf->digests_cnt)
12177 {
12178 salts_shown[salt_pos] = 1;
12179
12180 salts_done++;
12181 }
12182
12183 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12184 }
12185
12186 local_free (digests_buf);
12187 local_free (salts_buf);
12188 local_free (esalts_buf);
12189
12190 digests_buf = digests_buf_new;
12191 salts_buf = salts_buf_new;
12192 esalts_buf = esalts_buf_new;
12193
12194 local_free (hashes_buf);
12195
12196 /**
12197 * special modification not set from parser
12198 */
12199
12200 switch (hash_mode)
12201 {
12202 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12203 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12204 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12205 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12206 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12207 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12208 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12209 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12210 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12211 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12212 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12213 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12214 }
12215
12216 if (truecrypt_keyfiles)
12217 {
12218 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12219
12220 char *keyfiles = strdup (truecrypt_keyfiles);
12221
12222 char *keyfile = strtok (keyfiles, ",");
12223
12224 do
12225 {
12226 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12227
12228 } while ((keyfile = strtok (NULL, ",")) != NULL);
12229
12230 free (keyfiles);
12231 }
12232
12233 data.digests_cnt = digests_cnt;
12234 data.digests_done = digests_done;
12235 data.digests_buf = digests_buf;
12236 data.digests_shown = digests_shown;
12237 data.digests_shown_tmp = digests_shown_tmp;
12238
12239 data.salts_cnt = salts_cnt;
12240 data.salts_done = salts_done;
12241 data.salts_buf = salts_buf;
12242 data.salts_shown = salts_shown;
12243
12244 data.esalts_buf = esalts_buf;
12245 data.hash_info = hash_info;
12246
12247 /**
12248 * Automatic Optimizers
12249 */
12250
12251 if (salts_cnt == 1)
12252 opti_type |= OPTI_TYPE_SINGLE_SALT;
12253
12254 if (digests_cnt == 1)
12255 opti_type |= OPTI_TYPE_SINGLE_HASH;
12256
12257 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12258 opti_type |= OPTI_TYPE_NOT_ITERATED;
12259
12260 if (attack_mode == ATTACK_MODE_BF)
12261 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12262
12263 data.opti_type = opti_type;
12264
12265 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12266 {
12267 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12268 {
12269 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12270 {
12271 if (opts_type & OPTS_TYPE_ST_ADD80)
12272 {
12273 opts_type &= ~OPTS_TYPE_ST_ADD80;
12274 opts_type |= OPTS_TYPE_PT_ADD80;
12275 }
12276
12277 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12278 {
12279 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12280 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12281 }
12282
12283 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12284 {
12285 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12286 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12287 }
12288 }
12289 }
12290 }
12291
12292 /**
12293 * Some algorithm, like descrypt, can benefit from JIT compilation
12294 */
12295
12296 int force_jit_compilation = -1;
12297
12298 if (hash_mode == 8900)
12299 {
12300 force_jit_compilation = 8900;
12301 }
12302 else if (hash_mode == 9300)
12303 {
12304 force_jit_compilation = 8900;
12305 }
12306 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12307 {
12308 force_jit_compilation = 1500;
12309 }
12310
12311 /**
12312 * generate bitmap tables
12313 */
12314
12315 const uint bitmap_shift1 = 5;
12316 const uint bitmap_shift2 = 13;
12317
12318 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12319
12320 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12321 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12322 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12323 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12324 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12325 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12326 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12327 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12328
12329 uint bitmap_bits;
12330 uint bitmap_nums;
12331 uint bitmap_mask;
12332 uint bitmap_size;
12333
12334 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12335 {
12336 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12337
12338 bitmap_nums = 1 << bitmap_bits;
12339
12340 bitmap_mask = bitmap_nums - 1;
12341
12342 bitmap_size = bitmap_nums * sizeof (uint);
12343
12344 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12345
12346 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;
12347 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;
12348
12349 break;
12350 }
12351
12352 bitmap_nums = 1 << bitmap_bits;
12353
12354 bitmap_mask = bitmap_nums - 1;
12355
12356 bitmap_size = bitmap_nums * sizeof (uint);
12357
12358 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);
12359 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);
12360
12361 /**
12362 * prepare quick rule
12363 */
12364
12365 data.rule_buf_l = rule_buf_l;
12366 data.rule_buf_r = rule_buf_r;
12367
12368 int rule_len_l = (int) strlen (rule_buf_l);
12369 int rule_len_r = (int) strlen (rule_buf_r);
12370
12371 data.rule_len_l = rule_len_l;
12372 data.rule_len_r = rule_len_r;
12373
12374 /**
12375 * load rules
12376 */
12377
12378 uint *all_kernel_rules_cnt = NULL;
12379
12380 kernel_rule_t **all_kernel_rules_buf = NULL;
12381
12382 if (rp_files_cnt)
12383 {
12384 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12385
12386 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12387 }
12388
12389 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
12390
12391 int rule_len = 0;
12392
12393 for (uint i = 0; i < rp_files_cnt; i++)
12394 {
12395 uint kernel_rules_avail = 0;
12396
12397 uint kernel_rules_cnt = 0;
12398
12399 kernel_rule_t *kernel_rules_buf = NULL;
12400
12401 char *rp_file = rp_files[i];
12402
12403 char in[BLOCK_SIZE] = { 0 };
12404 char out[BLOCK_SIZE] = { 0 };
12405
12406 FILE *fp = NULL;
12407
12408 uint rule_line = 0;
12409
12410 if ((fp = fopen (rp_file, "rb")) == NULL)
12411 {
12412 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12413
12414 return (-1);
12415 }
12416
12417 while (!feof (fp))
12418 {
12419 memset (rule_buf, 0, HCBUFSIZ);
12420
12421 rule_len = fgetl (fp, rule_buf);
12422
12423 rule_line++;
12424
12425 if (rule_len == 0) continue;
12426
12427 if (rule_buf[0] == '#') continue;
12428
12429 if (kernel_rules_avail == kernel_rules_cnt)
12430 {
12431 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12432
12433 kernel_rules_avail += INCR_RULES;
12434 }
12435
12436 memset (in, 0, BLOCK_SIZE);
12437 memset (out, 0, BLOCK_SIZE);
12438
12439 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12440
12441 if (result == -1)
12442 {
12443 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12444
12445 continue;
12446 }
12447
12448 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12449 {
12450 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12451
12452 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12453
12454 continue;
12455 }
12456
12457 /* its so slow
12458 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12459 {
12460 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12461
12462 continue;
12463 }
12464 */
12465
12466 kernel_rules_cnt++;
12467 }
12468
12469 fclose (fp);
12470
12471 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12472
12473 all_kernel_rules_buf[i] = kernel_rules_buf;
12474 }
12475
12476 /**
12477 * merge rules or automatic rule generator
12478 */
12479
12480 uint kernel_rules_cnt = 0;
12481
12482 kernel_rule_t *kernel_rules_buf = NULL;
12483
12484 if (attack_mode == ATTACK_MODE_STRAIGHT)
12485 {
12486 if (rp_files_cnt)
12487 {
12488 kernel_rules_cnt = 1;
12489
12490 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12491
12492 repeats[0] = kernel_rules_cnt;
12493
12494 for (uint i = 0; i < rp_files_cnt; i++)
12495 {
12496 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12497
12498 repeats[i + 1] = kernel_rules_cnt;
12499 }
12500
12501 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12502
12503 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12504
12505 for (uint i = 0; i < kernel_rules_cnt; i++)
12506 {
12507 uint out_pos = 0;
12508
12509 kernel_rule_t *out = &kernel_rules_buf[i];
12510
12511 for (uint j = 0; j < rp_files_cnt; j++)
12512 {
12513 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12514 uint in_pos;
12515
12516 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12517
12518 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12519 {
12520 if (out_pos == RULES_MAX - 1)
12521 {
12522 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12523
12524 break;
12525 }
12526
12527 out->cmds[out_pos] = in->cmds[in_pos];
12528 }
12529 }
12530 }
12531
12532 local_free (repeats);
12533 }
12534 else if (rp_gen)
12535 {
12536 uint kernel_rules_avail = 0;
12537
12538 while (kernel_rules_cnt < rp_gen)
12539 {
12540 if (kernel_rules_avail == kernel_rules_cnt)
12541 {
12542 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12543
12544 kernel_rules_avail += INCR_RULES;
12545 }
12546
12547 memset (rule_buf, 0, HCBUFSIZ);
12548
12549 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12550
12551 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12552
12553 kernel_rules_cnt++;
12554 }
12555 }
12556 }
12557
12558 myfree (rule_buf);
12559
12560 /**
12561 * generate NOP rules
12562 */
12563
12564 if (kernel_rules_cnt == 0)
12565 {
12566 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12567
12568 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12569
12570 kernel_rules_cnt++;
12571 }
12572
12573 data.kernel_rules_cnt = kernel_rules_cnt;
12574 data.kernel_rules_buf = kernel_rules_buf;
12575
12576 /**
12577 * OpenCL platforms: detect
12578 */
12579
12580 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
12581 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
12582
12583 cl_uint platforms_cnt = 0;
12584 cl_uint platform_devices_cnt = 0;
12585
12586 if (keyspace == 0)
12587 {
12588 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12589
12590 if (platforms_cnt == 0)
12591 {
12592 log_error ("ERROR: No OpenCL compatible platform found");
12593
12594 return (-1);
12595 }
12596
12597 if (opencl_platforms_filter != (uint) -1)
12598 {
12599 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
12600
12601 if (opencl_platforms_filter > platform_cnt_mask)
12602 {
12603 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
12604
12605 return (-1);
12606 }
12607 }
12608 }
12609
12610 /**
12611 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12612 */
12613
12614 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12615 {
12616 cl_platform_id platform = platforms[platform_id];
12617
12618 char platform_vendor[INFOSZ] = { 0 };
12619
12620 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12621
12622 #ifdef HAVE_HWMON
12623 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12624 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12625 {
12626 // make sure that we do not directly control the fan for NVidia
12627
12628 gpu_temp_retain = 0;
12629
12630 data.gpu_temp_retain = gpu_temp_retain;
12631 }
12632 #endif // HAVE_NVML || HAVE_NVAPI
12633 #endif
12634 }
12635
12636 /**
12637 * OpenCL devices: simply push all devices from all platforms into the same device array
12638 */
12639
12640 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12641
12642 data.devices_param = devices_param;
12643
12644 uint devices_cnt = 0;
12645
12646 uint devices_active = 0;
12647
12648 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12649 {
12650 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12651
12652 cl_platform_id platform = platforms[platform_id];
12653
12654 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12655
12656 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12657 {
12658 size_t param_value_size = 0;
12659
12660 const uint device_id = devices_cnt;
12661
12662 hc_device_param_t *device_param = &data.devices_param[device_id];
12663
12664 device_param->device = platform_devices[platform_devices_id];
12665
12666 device_param->device_id = device_id;
12667
12668 device_param->platform_devices_id = platform_devices_id;
12669
12670 // device_type
12671
12672 cl_device_type device_type;
12673
12674 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12675
12676 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12677
12678 device_param->device_type = device_type;
12679
12680 // vendor_id
12681
12682 cl_uint vendor_id = 0;
12683
12684 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR_ID, sizeof (vendor_id), &vendor_id, NULL);
12685
12686 device_param->vendor_id = vendor_id;
12687
12688 // device_name
12689
12690 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
12691
12692 char *device_name = (char *) mymalloc (param_value_size);
12693
12694 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
12695
12696 device_param->device_name = device_name;
12697
12698 // tuning db
12699
12700 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
12701
12702 // device_version
12703
12704 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
12705
12706 char *device_version = (char *) mymalloc (param_value_size);
12707
12708 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
12709
12710 device_param->device_version = device_version;
12711
12712 // device_opencl_version
12713
12714 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
12715
12716 char *device_opencl_version = (char *) mymalloc (param_value_size);
12717
12718 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
12719
12720 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
12721
12722 myfree (device_opencl_version);
12723
12724 if (strstr (device_version, "pocl"))
12725 {
12726 // pocl returns the real vendor_id in CL_DEVICE_VENDOR_ID which causes many problems because of hms and missing amd_bfe () etc
12727 // we need to overwrite vendor_id to avoid this. maybe open pocl issue?
12728
12729 cl_uint vendor_id = VENDOR_ID_GENERIC;
12730
12731 device_param->vendor_id = vendor_id;
12732 }
12733
12734 // vector_width
12735
12736 cl_uint vector_width;
12737
12738 if (opencl_vector_width_chgd == 0)
12739 {
12740 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
12741 {
12742 if (opti_type & OPTI_TYPE_USES_BITS_64)
12743 {
12744 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
12745 }
12746 else
12747 {
12748 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12749 }
12750 }
12751 else
12752 {
12753 vector_width = (cl_uint) tuningdb_entry->vector_width;
12754 }
12755 }
12756 else
12757 {
12758 vector_width = opencl_vector_width;
12759 }
12760
12761 if (vector_width > 16) vector_width = 16;
12762
12763 device_param->vector_width = vector_width;
12764
12765 // max_compute_units
12766
12767 cl_uint device_processors;
12768
12769 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12770
12771 device_param->device_processors = device_processors;
12772
12773 // max_mem_alloc_size
12774
12775 cl_ulong device_maxmem_alloc;
12776
12777 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12778
12779 device_param->device_maxmem_alloc = device_maxmem_alloc;
12780
12781 // max_mem_alloc_size
12782
12783 cl_ulong device_global_mem;
12784
12785 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12786
12787 device_param->device_global_mem = device_global_mem;
12788
12789 // max_clock_frequency
12790
12791 cl_uint device_maxclock_frequency;
12792
12793 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12794
12795 device_param->device_maxclock_frequency = device_maxclock_frequency;
12796
12797 // skipped
12798
12799 const u32 skipped1 = ((devices_filter & (1 << device_id)) == 0);
12800 const u32 skipped2 = ((device_types_filter & (device_type)) == 0);
12801
12802 device_param->skipped = (skipped1 || skipped2);
12803
12804 // driver_version
12805 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
12806
12807 char *driver_version = (char *) mymalloc (param_value_size);
12808
12809 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
12810
12811 device_param->driver_version = driver_version;
12812
12813 // device_name_chksum
12814
12815 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12816
12817 #if __x86_64__
12818 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);
12819 #else
12820 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);
12821 #endif
12822
12823 uint device_name_digest[4] = { 0 };
12824
12825 md5_64 ((uint *) device_name_chksum, device_name_digest);
12826
12827 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
12828
12829 device_param->device_name_chksum = device_name_chksum;
12830
12831 // device_processor_cores
12832
12833 if (device_type & CL_DEVICE_TYPE_CPU)
12834 {
12835 cl_uint device_processor_cores = 1;
12836
12837 device_param->device_processor_cores = device_processor_cores;
12838 }
12839
12840 if (device_type & CL_DEVICE_TYPE_GPU)
12841 {
12842 if (vendor_id == VENDOR_ID_AMD)
12843 {
12844 cl_uint device_processor_cores = 0;
12845
12846 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12847
12848 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12849
12850 device_param->device_processor_cores = device_processor_cores;
12851 }
12852 else if (vendor_id == VENDOR_ID_NV)
12853 {
12854 cl_uint kernel_exec_timeout = 0;
12855
12856 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12857
12858 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12859
12860 device_param->kernel_exec_timeout = kernel_exec_timeout;
12861
12862 cl_uint device_processor_cores = 0;
12863
12864 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12865
12866 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12867
12868 device_param->device_processor_cores = device_processor_cores;
12869
12870 cl_uint sm_minor = 0;
12871 cl_uint sm_major = 0;
12872
12873 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12874 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12875
12876 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12877 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12878
12879 device_param->sm_minor = sm_minor;
12880 device_param->sm_major = sm_major;
12881 }
12882 else
12883 {
12884 cl_uint device_processor_cores = 1;
12885
12886 device_param->device_processor_cores = device_processor_cores;
12887 }
12888 }
12889
12890 // display results
12891
12892 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12893 {
12894 if (device_param->skipped == 0)
12895 {
12896 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12897 device_id + 1,
12898 device_name,
12899 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
12900 (unsigned int) (device_global_mem / 1024 / 1024),
12901 (unsigned int) (device_maxclock_frequency),
12902 (unsigned int) device_processors);
12903 }
12904 else
12905 {
12906 log_info ("Device #%u: %s, skipped",
12907 device_id + 1,
12908 device_name);
12909 }
12910 }
12911
12912 // common driver check
12913
12914 if (device_param->skipped == 0)
12915 {
12916 if (strstr (device_version, "pocl"))
12917 {
12918 if (force == 0)
12919 {
12920 log_info ("");
12921 log_info ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
12922 log_info ("You are STRONGLY encouraged not to use it");
12923 log_info ("You can use --force to override this but do not post error reports if you do so");
12924 log_info ("");
12925
12926 return (-1);
12927 }
12928 }
12929
12930 if (device_type & CL_DEVICE_TYPE_GPU)
12931 {
12932 if (vendor_id == VENDOR_ID_NV)
12933 {
12934 if (device_param->kernel_exec_timeout != 0)
12935 {
12936 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);
12937 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12938 }
12939 }
12940 else if (vendor_id == VENDOR_ID_AMD)
12941 {
12942 int catalyst_check = (force == 1) ? 0 : 1;
12943
12944 int catalyst_warn = 0;
12945
12946 int catalyst_broken = 0;
12947
12948 if (catalyst_check == 1)
12949 {
12950 catalyst_warn = 1;
12951
12952 // v14.9 and higher
12953 if (atoi (device_param->driver_version) >= 1573)
12954 {
12955 catalyst_warn = 0;
12956 }
12957
12958 catalyst_check = 0;
12959 }
12960
12961 if (catalyst_broken == 1)
12962 {
12963 log_info ("");
12964 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
12965 log_info ("It will pass over cracked hashes and does not report them as cracked");
12966 log_info ("You are STRONGLY encouraged not to use it");
12967 log_info ("You can use --force to override this but do not post error reports if you do so");
12968 log_info ("");
12969
12970 return (-1);
12971 }
12972
12973 if (catalyst_warn == 1)
12974 {
12975 log_info ("");
12976 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
12977 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
12978 log_info ("See oclHashcat's homepage for official supported catalyst drivers");
12979 #ifdef _WIN
12980 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
12981 #endif
12982 log_info ("You can use --force to override this but do not post error reports if you do so");
12983 log_info ("");
12984
12985 return (-1);
12986 }
12987 }
12988 }
12989
12990 /**
12991 * kernel accel and loops tuning db adjustment
12992 */
12993
12994 device_param->kernel_accel_min = 1;
12995 device_param->kernel_accel_max = 1024;
12996
12997 device_param->kernel_loops_min = 1;
12998 device_param->kernel_loops_max = 1024;
12999
13000 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13001
13002 if (tuningdb_entry)
13003 {
13004 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13005 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13006
13007 if (_kernel_accel)
13008 {
13009 device_param->kernel_accel_min = _kernel_accel;
13010 device_param->kernel_accel_max = _kernel_accel;
13011 }
13012
13013 if (_kernel_loops)
13014 {
13015 if (workload_profile == 1)
13016 {
13017 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13018 }
13019 else if (workload_profile == 2)
13020 {
13021 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13022 }
13023
13024 device_param->kernel_loops_min = _kernel_loops;
13025 device_param->kernel_loops_max = _kernel_loops;
13026 }
13027 }
13028
13029 // commandline parameters overwrite tuningdb entries
13030
13031 if (kernel_accel)
13032 {
13033 device_param->kernel_accel_min = kernel_accel;
13034 device_param->kernel_accel_max = kernel_accel;
13035 }
13036
13037 if (kernel_loops)
13038 {
13039 device_param->kernel_loops_min = kernel_loops;
13040 device_param->kernel_loops_max = kernel_loops;
13041 }
13042
13043 /**
13044 * activate device
13045 */
13046
13047 devices_active++;
13048 }
13049
13050 // next please
13051
13052 devices_cnt++;
13053 }
13054 }
13055
13056 if (keyspace == 0 && devices_active == 0)
13057 {
13058 log_error ("ERROR: No devices found/left");
13059
13060 return (-1);
13061 }
13062
13063 // 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)
13064
13065 if (devices_filter != (uint) -1)
13066 {
13067 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
13068
13069 if (devices_filter > devices_cnt_mask)
13070 {
13071 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
13072
13073 return (-1);
13074 }
13075 }
13076
13077 data.devices_cnt = devices_cnt;
13078
13079 data.devices_active = devices_active;
13080
13081 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13082 {
13083 log_info ("");
13084 }
13085
13086 /**
13087 * HM devices: init
13088 */
13089
13090 #ifdef HAVE_HWMON
13091 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13092 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13093 #endif
13094
13095 #ifdef HAVE_ADL
13096 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13097 #endif
13098
13099 if (gpu_temp_disable == 0)
13100 {
13101 #if defined(WIN) && defined(HAVE_NVAPI)
13102 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13103
13104 if (nvapi_init (nvapi) == 0)
13105 data.hm_nv = nvapi;
13106
13107 if (data.hm_nv)
13108 {
13109 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13110 {
13111 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13112
13113 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13114
13115 int tmp_out = 0;
13116
13117 for (int i = 0; i < tmp_in; i++)
13118 {
13119 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13120 }
13121
13122 for (int i = 0; i < tmp_out; i++)
13123 {
13124 NV_GPU_COOLER_SETTINGS pCoolerSettings;
13125
13126 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
13127
13128 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;
13129 }
13130 }
13131 }
13132 #endif // WIN && HAVE_NVAPI
13133
13134 #if defined(LINUX) && defined(HAVE_NVML)
13135 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13136
13137 if (nvml_init (nvml) == 0)
13138 data.hm_nv = nvml;
13139
13140 if (data.hm_nv)
13141 {
13142 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13143 {
13144 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13145
13146 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13147
13148 int tmp_out = 0;
13149
13150 for (int i = 0; i < tmp_in; i++)
13151 {
13152 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13153 }
13154
13155 for (int i = 0; i < tmp_out; i++)
13156 {
13157 unsigned int speed;
13158
13159 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;
13160 }
13161 }
13162 }
13163 #endif // LINUX && HAVE_NVML
13164
13165 data.hm_amd = NULL;
13166
13167 #ifdef HAVE_ADL
13168 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13169
13170 if (adl_init (adl) == 0)
13171 data.hm_amd = adl;
13172
13173 if (data.hm_amd)
13174 {
13175 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13176 {
13177 // total number of adapters
13178
13179 int hm_adapters_num;
13180
13181 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13182
13183 // adapter info
13184
13185 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13186
13187 if (lpAdapterInfo == NULL) return (-1);
13188
13189 // get a list (of ids of) valid/usable adapters
13190
13191 int num_adl_adapters = 0;
13192
13193 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13194
13195 if (num_adl_adapters > 0)
13196 {
13197 hc_thread_mutex_lock (mux_adl);
13198
13199 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13200
13201 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13202
13203 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13204 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13205
13206 hc_thread_mutex_unlock (mux_adl);
13207 }
13208
13209 myfree (valid_adl_device_list);
13210 myfree (lpAdapterInfo);
13211 }
13212 }
13213 #endif // HAVE_ADL
13214
13215 if (data.hm_amd == NULL && data.hm_nv == NULL)
13216 {
13217 gpu_temp_disable = 1;
13218 }
13219 }
13220
13221 /**
13222 * OpenCL devices: allocate buffer for device specific information
13223 */
13224
13225 #ifdef HAVE_HWMON
13226 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13227
13228 #ifdef HAVE_ADL
13229 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13230
13231 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13232 #endif // ADL
13233 #endif
13234
13235 /**
13236 * enable custom signal handler(s)
13237 */
13238
13239 if (benchmark == 0)
13240 {
13241 hc_signal (sigHandler_default);
13242 }
13243 else
13244 {
13245 hc_signal (sigHandler_benchmark);
13246 }
13247
13248 /**
13249 * User-defined GPU temp handling
13250 */
13251
13252 #ifdef HAVE_HWMON
13253 if (gpu_temp_disable == 1)
13254 {
13255 gpu_temp_abort = 0;
13256 gpu_temp_retain = 0;
13257 }
13258
13259 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13260 {
13261 if (gpu_temp_abort < gpu_temp_retain)
13262 {
13263 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13264
13265 return (-1);
13266 }
13267 }
13268
13269 data.gpu_temp_disable = gpu_temp_disable;
13270 data.gpu_temp_abort = gpu_temp_abort;
13271 data.gpu_temp_retain = gpu_temp_retain;
13272 #endif
13273
13274 /**
13275 * inform the user
13276 */
13277
13278 if (data.quiet == 0)
13279 {
13280 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13281
13282 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);
13283
13284 if (attack_mode == ATTACK_MODE_STRAIGHT)
13285 {
13286 log_info ("Rules: %u", kernel_rules_cnt);
13287 }
13288
13289 if (opti_type)
13290 {
13291 log_info ("Applicable Optimizers:");
13292
13293 for (uint i = 0; i < 32; i++)
13294 {
13295 const uint opti_bit = 1u << i;
13296
13297 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13298 }
13299 }
13300
13301 /**
13302 * Watchdog and Temperature balance
13303 */
13304
13305 #ifdef HAVE_HWMON
13306 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13307 {
13308 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13309 }
13310
13311 if (gpu_temp_abort == 0)
13312 {
13313 log_info ("Watchdog: Temperature abort trigger disabled");
13314 }
13315 else
13316 {
13317 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13318 }
13319
13320 if (gpu_temp_retain == 0)
13321 {
13322 log_info ("Watchdog: Temperature retain trigger disabled");
13323 }
13324 else
13325 {
13326 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13327 }
13328 #endif
13329 }
13330
13331 if (data.quiet == 0) log_info ("");
13332
13333 /**
13334 * HM devices: copy
13335 */
13336
13337 if (gpu_temp_disable == 0)
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->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13344
13345 if (device_param->skipped) continue;
13346
13347 const uint platform_devices_id = device_param->platform_devices_id;
13348
13349 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13350 if (device_param->vendor_id == VENDOR_ID_NV)
13351 {
13352 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13353 }
13354 #endif
13355
13356 #ifdef HAVE_ADL
13357 if (device_param->vendor_id == VENDOR_ID_AMD)
13358 {
13359 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13360 }
13361 #endif
13362 }
13363 }
13364
13365 /*
13366 * Temporary fix:
13367 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13368 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13369 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13370 * Driver / ADL bug?
13371 */
13372
13373 #ifdef HAVE_ADL
13374 if (powertune_enable == 1)
13375 {
13376 hc_thread_mutex_lock (mux_adl);
13377
13378 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13379 {
13380 hc_device_param_t *device_param = &data.devices_param[device_id];
13381
13382 if (device_param->skipped) continue;
13383
13384 if (data.hm_device[device_id].od_version == 6)
13385 {
13386 // set powertune value only
13387
13388 int powertune_supported = 0;
13389
13390 int ADL_rc = 0;
13391
13392 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13393 {
13394 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13395
13396 return (-1);
13397 }
13398
13399 if (powertune_supported != 0)
13400 {
13401 // powertune set
13402 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13403
13404 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13405 {
13406 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13407
13408 return (-1);
13409 }
13410
13411 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13412 {
13413 log_error ("ERROR: Failed to set new ADL PowerControl values");
13414
13415 return (-1);
13416 }
13417 }
13418 }
13419 }
13420
13421 hc_thread_mutex_unlock (mux_adl);
13422 }
13423 #endif // HAVE_ADK
13424 #endif // HAVE_HWMON
13425
13426 #ifdef DEBUG
13427 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
13428 #endif
13429
13430 uint kernel_power_all = 0;
13431
13432 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13433 {
13434 /**
13435 * host buffer
13436 */
13437
13438 hc_device_param_t *device_param = &data.devices_param[device_id];
13439
13440 if (device_param->skipped) continue;
13441
13442 /**
13443 * device properties
13444 */
13445
13446 const char *device_name_chksum = device_param->device_name_chksum;
13447 const u32 device_processors = device_param->device_processors;
13448 const u32 device_processor_cores = device_param->device_processor_cores;
13449
13450 /**
13451 * create context for each device
13452 */
13453
13454 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
13455
13456 /**
13457 * create command-queue
13458 */
13459
13460 // not supported with NV
13461 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13462
13463 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
13464
13465 /**
13466 * create input buffers on device : calculate size of fixed memory buffers
13467 */
13468
13469 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13470 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13471
13472 device_param->size_root_css = size_root_css;
13473 device_param->size_markov_css = size_markov_css;
13474
13475 uint size_results = KERNEL_THREADS * sizeof (uint);
13476
13477 device_param->size_results = size_results;
13478
13479 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13480 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13481
13482 uint size_plains = digests_cnt * sizeof (plain_t);
13483 uint size_salts = salts_cnt * sizeof (salt_t);
13484 uint size_esalts = salts_cnt * esalt_size;
13485
13486 device_param->size_plains = size_plains;
13487 device_param->size_digests = size_digests;
13488 device_param->size_shown = size_shown;
13489 device_param->size_salts = size_salts;
13490
13491 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13492 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13493 uint size_tm = 32 * sizeof (bs_word_t);
13494
13495 // scryptV stuff
13496
13497 u64 size_scryptV = 1;
13498
13499 if ((hash_mode == 8900) || (hash_mode == 9300))
13500 {
13501 uint tmto_start = 0;
13502 uint tmto_stop = 10;
13503
13504 if (scrypt_tmto)
13505 {
13506 tmto_start = scrypt_tmto;
13507 }
13508 else
13509 {
13510 // in case the user did not specify the tmto manually
13511 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13512 // but set the lower end only in case the user has a device with too less memory
13513
13514 if (hash_mode == 8900)
13515 {
13516 if (device_param->vendor_id == VENDOR_ID_AMD)
13517 {
13518 tmto_start = 1;
13519 }
13520 else if (device_param->vendor_id == VENDOR_ID_NV)
13521 {
13522 tmto_start = 3;
13523 }
13524 }
13525 else if (hash_mode == 9300)
13526 {
13527 if (device_param->vendor_id == VENDOR_ID_AMD)
13528 {
13529 tmto_start = 3;
13530 }
13531 else if (device_param->vendor_id == VENDOR_ID_NV)
13532 {
13533 tmto_start = 5;
13534 }
13535 }
13536 }
13537
13538 if (quiet == 0) log_info ("");
13539
13540 uint shader_per_mp = 1;
13541
13542 if (device_param->vendor_id == VENDOR_ID_AMD)
13543 {
13544 shader_per_mp = 8;
13545 }
13546 else if (device_param->vendor_id == VENDOR_ID_NV)
13547 {
13548 shader_per_mp = 32;
13549 }
13550
13551 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13552 {
13553 // TODO: in theory the following calculation needs to be done per salt, not global
13554 // we assume all hashes have the same scrypt settings
13555
13556 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13557
13558 size_scryptV /= 1 << tmto;
13559
13560 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13561
13562 if (size_scryptV > device_param->device_maxmem_alloc)
13563 {
13564 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13565
13566 continue;
13567 }
13568
13569 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13570 {
13571 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13572 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13573 }
13574
13575 break;
13576 }
13577
13578 if (data.salts_buf[0].scrypt_phy == 0)
13579 {
13580 log_error ("ERROR: can't allocate enough device memory");
13581
13582 return -1;
13583 }
13584
13585 if (quiet == 0) log_info ("");
13586 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13587 }
13588
13589 /**
13590 * create input buffers on device : calculate size of dynamic size memory buffers
13591 */
13592
13593 uint kernel_threads = KERNEL_THREADS;
13594
13595 // some algorithms need a fixed kernel-threads count (mostly because of shared memory usage)
13596
13597 if (hash_mode == 3200) kernel_threads = 8;
13598 if (hash_mode == 9000) kernel_threads = 8;
13599
13600 /**
13601 * some algorithms need a fixed kernel-loops count
13602 */
13603
13604 if (hash_mode == 1500)
13605 {
13606 const u32 kernel_loops_fixed = 1024;
13607
13608 device_param->kernel_loops_min = kernel_loops_fixed;
13609 device_param->kernel_loops_max = kernel_loops_fixed;
13610 }
13611
13612 if (hash_mode == 3000)
13613 {
13614 const u32 kernel_loops_fixed = 1024;
13615
13616 device_param->kernel_loops_min = kernel_loops_fixed;
13617 device_param->kernel_loops_max = kernel_loops_fixed;
13618 }
13619
13620 if (hash_mode == 8900)
13621 {
13622 const u32 kernel_loops_fixed = 1;
13623
13624 device_param->kernel_loops_min = kernel_loops_fixed;
13625 device_param->kernel_loops_max = kernel_loops_fixed;
13626 }
13627
13628 if (hash_mode == 9300)
13629 {
13630 const u32 kernel_loops_fixed = 1;
13631
13632 device_param->kernel_loops_min = kernel_loops_fixed;
13633 device_param->kernel_loops_max = kernel_loops_fixed;
13634 }
13635
13636 if (hash_mode == 12500)
13637 {
13638 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
13639
13640 device_param->kernel_loops_min = kernel_loops_fixed;
13641 device_param->kernel_loops_max = kernel_loops_fixed;
13642 }
13643
13644 /**
13645 * some algorithms have a maximum kernel-loops count
13646 */
13647
13648 if (attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
13649 {
13650 if (data.salts_buf[0].salt_iter < device_param->kernel_loops_max)
13651 {
13652 device_param->kernel_loops_max = data.salts_buf[0].salt_iter;
13653 }
13654 }
13655
13656 /**
13657 * some algorithms need a special kernel-accel
13658 */
13659
13660 if (hash_mode == 8900)
13661 {
13662 device_param->kernel_accel_min = 1;
13663 device_param->kernel_accel_max = 64;
13664 }
13665
13666 if (hash_mode == 9300)
13667 {
13668 device_param->kernel_accel_min = 1;
13669 device_param->kernel_accel_max = 64;
13670 }
13671
13672 u32 kernel_accel_min = device_param->kernel_accel_min;
13673 u32 kernel_accel_max = device_param->kernel_accel_max;
13674
13675 // find out if we would request too much memory on memory blocks which are based on kernel_accel
13676
13677 uint size_pws = 4;
13678 uint size_tmps = 4;
13679 uint size_hooks = 4;
13680
13681 while (kernel_accel_max >= kernel_accel_min)
13682 {
13683 uint kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
13684
13685 // size_pws
13686
13687 size_pws = kernel_power_max * sizeof (pw_t);
13688
13689 // size_tmps
13690
13691 switch (hash_mode)
13692 {
13693 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
13694 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13695 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13696 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13697 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
13698 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
13699 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
13700 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
13701 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
13702 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
13703 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13704 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13705 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13706 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13707 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13708 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13709 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13710 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13711 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13712 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13713 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13714 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13715 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13716 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
13717 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
13718 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
13719 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
13720 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
13721 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13722 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13723 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
13724 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
13725 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13726 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
13727 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13728 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
13729 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
13730 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13731 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13732 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
13733 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
13734 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
13735 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13736 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
13737 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
13738 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
13739 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
13740 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13741 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
13742 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
13743 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
13744 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
13745 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13746 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
13747 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
13748 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
13749 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
13750 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
13751 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13752 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13753 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13754 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
13755 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
13756 };
13757
13758 // size_hooks
13759
13760 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13761 {
13762 // none yet
13763 }
13764
13765 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
13766 // if not, decrease amplifier and try again
13767
13768 int skip = 0;
13769
13770 if (size_pws > device_param->device_maxmem_alloc) skip = 1;
13771 if (size_tmps > device_param->device_maxmem_alloc) skip = 1;
13772 if (size_hooks > device_param->device_maxmem_alloc) skip = 1;
13773
13774 if (( bitmap_size
13775 + bitmap_size
13776 + bitmap_size
13777 + bitmap_size
13778 + bitmap_size
13779 + bitmap_size
13780 + bitmap_size
13781 + bitmap_size
13782 + size_bfs
13783 + size_combs
13784 + size_digests
13785 + size_esalts
13786 + size_hooks
13787 + size_markov_css
13788 + size_plains
13789 + size_pws
13790 + size_results
13791 + size_root_css
13792 + size_rules
13793 + size_rules_c
13794 + size_salts
13795 + size_scryptV
13796 + size_shown
13797 + size_tm
13798 + size_tmps) > device_param->device_global_mem) skip = 1;
13799
13800 if (skip == 1)
13801 {
13802 kernel_accel_max--;
13803
13804 continue;
13805 }
13806
13807 break;
13808 }
13809
13810 /*
13811 if (kernel_accel_max == 0)
13812 {
13813 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
13814
13815 return -1;
13816 }
13817 */
13818
13819 device_param->kernel_accel_min = kernel_accel_min;
13820 device_param->kernel_accel_max = kernel_accel_max;
13821
13822 /*
13823 if (kernel_accel_max < kernel_accel)
13824 {
13825 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
13826
13827 device_param->kernel_accel = kernel_accel_max;
13828 }
13829 */
13830
13831 device_param->size_bfs = size_bfs;
13832 device_param->size_combs = size_combs;
13833 device_param->size_rules = size_rules;
13834 device_param->size_rules_c = size_rules_c;
13835 device_param->size_pws = size_pws;
13836 device_param->size_tmps = size_tmps;
13837 device_param->size_hooks = size_hooks;
13838
13839 // do not confuse kernel_accel_max with kernel_accel here
13840
13841 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
13842
13843 device_param->kernel_threads = kernel_threads;
13844 device_param->kernel_power_user = kernel_power;
13845
13846 kernel_power_all += kernel_power;
13847
13848 /**
13849 * default building options
13850 */
13851
13852 char build_opts[1024] = { 0 };
13853
13854 // we don't have sm_* on vendors not NV but it doesn't matter
13855
13856 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);
13857
13858 /**
13859 * main kernel
13860 */
13861
13862 {
13863 /**
13864 * kernel source filename
13865 */
13866
13867 char source_file[256] = { 0 };
13868
13869 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13870
13871 struct stat sst;
13872
13873 if (stat (source_file, &sst) == -1)
13874 {
13875 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13876
13877 return -1;
13878 }
13879
13880 /**
13881 * kernel cached filename
13882 */
13883
13884 char cached_file[256] = { 0 };
13885
13886 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
13887
13888 int cached = 1;
13889
13890 struct stat cst;
13891
13892 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
13893 {
13894 cached = 0;
13895 }
13896
13897 /**
13898 * kernel compile or load
13899 */
13900
13901 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13902
13903 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13904
13905 if (force_jit_compilation == -1)
13906 {
13907 if (cached == 0)
13908 {
13909 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13910
13911 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13912
13913 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13914
13915 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
13916
13917 #ifdef DEBUG
13918 size_t build_log_size = 0;
13919
13920 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
13921
13922 if (build_log_size > 1)
13923 {
13924 char *build_log = (char *) malloc (build_log_size + 1);
13925
13926 memset (build_log, 0, build_log_size + 1);
13927
13928 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
13929
13930 puts (build_log);
13931
13932 free (build_log);
13933 }
13934 #endif
13935
13936 if (rc != 0)
13937 {
13938 device_param->skipped = true;
13939 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13940 continue;
13941 }
13942
13943 size_t binary_size;
13944
13945 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13946
13947 u8 *binary = (u8 *) mymalloc (binary_size);
13948
13949 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13950
13951 writeProgramBin (cached_file, binary, binary_size);
13952
13953 local_free (binary);
13954 }
13955 else
13956 {
13957 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13958
13959 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13960
13961 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13962
13963 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
13964 }
13965 }
13966 else
13967 {
13968 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13969
13970 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13971
13972 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13973
13974 char build_opts_update[1024] = { 0 };
13975
13976 if (force_jit_compilation == 1500)
13977 {
13978 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13979 }
13980 else if (force_jit_compilation == 8900)
13981 {
13982 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);
13983 }
13984 else
13985 {
13986 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
13987 }
13988
13989 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
13990
13991 #ifdef DEBUG
13992 size_t build_log_size = 0;
13993
13994 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
13995
13996 if (build_log_size > 1)
13997 {
13998 char *build_log = (char *) malloc (build_log_size + 1);
13999
14000 memset (build_log, 0, build_log_size + 1);
14001
14002 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14003
14004 puts (build_log);
14005
14006 free (build_log);
14007 }
14008 #endif
14009
14010 if (rc != 0)
14011 {
14012 device_param->skipped = true;
14013
14014 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14015 }
14016 }
14017
14018 local_free (kernel_lengths);
14019 local_free (kernel_sources[0]);
14020 local_free (kernel_sources);
14021 }
14022
14023 /**
14024 * word generator kernel
14025 */
14026
14027 if (attack_mode != ATTACK_MODE_STRAIGHT)
14028 {
14029 /**
14030 * kernel mp source filename
14031 */
14032
14033 char source_file[256] = { 0 };
14034
14035 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
14036
14037 struct stat sst;
14038
14039 if (stat (source_file, &sst) == -1)
14040 {
14041 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14042
14043 return -1;
14044 }
14045
14046 /**
14047 * kernel mp cached filename
14048 */
14049
14050 char cached_file[256] = { 0 };
14051
14052 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
14053
14054 int cached = 1;
14055
14056 struct stat cst;
14057
14058 if (stat (cached_file, &cst) == -1)
14059 {
14060 cached = 0;
14061 }
14062
14063 /**
14064 * kernel compile or load
14065 */
14066
14067 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14068
14069 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14070
14071 if (cached == 0)
14072 {
14073 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14074
14075 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14076
14077 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14078
14079 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
14080
14081 if (rc != 0)
14082 {
14083 device_param->skipped = true;
14084 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14085 continue;
14086 }
14087
14088 size_t binary_size;
14089
14090 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14091
14092 u8 *binary = (u8 *) mymalloc (binary_size);
14093
14094 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14095
14096 writeProgramBin (cached_file, binary, binary_size);
14097
14098 local_free (binary);
14099 }
14100 else
14101 {
14102 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14103
14104 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14105
14106 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14107
14108 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
14109 }
14110
14111 local_free (kernel_lengths);
14112 local_free (kernel_sources[0]);
14113 local_free (kernel_sources);
14114 }
14115
14116 /**
14117 * amplifier kernel
14118 */
14119
14120 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14121 {
14122
14123 }
14124 else
14125 {
14126 /**
14127 * kernel amp source filename
14128 */
14129
14130 char source_file[256] = { 0 };
14131
14132 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
14133
14134 struct stat sst;
14135
14136 if (stat (source_file, &sst) == -1)
14137 {
14138 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14139
14140 return -1;
14141 }
14142
14143 /**
14144 * kernel amp cached filename
14145 */
14146
14147 char cached_file[256] = { 0 };
14148
14149 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
14150
14151 int cached = 1;
14152
14153 struct stat cst;
14154
14155 if (stat (cached_file, &cst) == -1)
14156 {
14157 cached = 0;
14158 }
14159
14160 /**
14161 * kernel compile or load
14162 */
14163
14164 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14165
14166 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14167
14168 if (cached == 0)
14169 {
14170 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14171
14172 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14173
14174 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14175
14176 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
14177
14178 if (rc != 0)
14179 {
14180 device_param->skipped = true;
14181 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14182 continue;
14183 }
14184
14185 size_t binary_size;
14186
14187 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14188
14189 u8 *binary = (u8 *) mymalloc (binary_size);
14190
14191 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14192
14193 writeProgramBin (cached_file, binary, binary_size);
14194
14195 local_free (binary);
14196 }
14197 else
14198 {
14199 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14200
14201 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14202
14203 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14204
14205 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
14206 }
14207
14208 local_free (kernel_lengths);
14209 local_free (kernel_sources[0]);
14210 local_free (kernel_sources);
14211 }
14212
14213 // some algorithm collide too fast, make that impossible
14214
14215 if (benchmark == 1)
14216 {
14217 ((uint *) digests_buf)[0] = -1;
14218 ((uint *) digests_buf)[1] = -1;
14219 ((uint *) digests_buf)[2] = -1;
14220 ((uint *) digests_buf)[3] = -1;
14221 }
14222
14223 /**
14224 * global buffers
14225 */
14226
14227 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14228 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14229 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
14230 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
14231 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14232 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14233 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14234 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14235 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14236 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14237 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14238 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14239 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
14240 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
14241 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
14242 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
14243 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
14244 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
14245
14246 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);
14247 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);
14248 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);
14249 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);
14250 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);
14251 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);
14252 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);
14253 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);
14254 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
14255 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
14256 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
14257
14258 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
14259 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
14260 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
14261 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
14262 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
14263 run_kernel_bzero (device_param, device_param->d_result, size_results);
14264
14265 /**
14266 * special buffers
14267 */
14268
14269 if (attack_kern == ATTACK_KERN_STRAIGHT)
14270 {
14271 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
14272 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
14273
14274 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
14275
14276 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
14277 }
14278 else if (attack_kern == ATTACK_KERN_COMBI)
14279 {
14280 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14281 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14282 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14283 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14284
14285 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
14286 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
14287 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14288 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14289 }
14290 else if (attack_kern == ATTACK_KERN_BF)
14291 {
14292 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14293 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14294 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
14295 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14296 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14297
14298 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
14299 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
14300 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
14301 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14302 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14303 }
14304
14305 if (size_esalts)
14306 {
14307 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
14308
14309 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
14310 }
14311
14312 /**
14313 * main host data
14314 */
14315
14316 uint *result = (uint *) mymalloc (size_results);
14317
14318 device_param->result = result;
14319
14320 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
14321
14322 device_param->pws_buf = pws_buf;
14323
14324 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
14325
14326 device_param->combs_buf = combs_buf;
14327
14328 void *hooks_buf = mymalloc (size_hooks);
14329
14330 device_param->hooks_buf = hooks_buf;
14331
14332 /**
14333 * kernel args
14334 */
14335
14336 device_param->kernel_params_buf32[21] = bitmap_mask;
14337 device_param->kernel_params_buf32[22] = bitmap_shift1;
14338 device_param->kernel_params_buf32[23] = bitmap_shift2;
14339 device_param->kernel_params_buf32[24] = 0; // salt_pos
14340 device_param->kernel_params_buf32[25] = 0; // loop_pos
14341 device_param->kernel_params_buf32[26] = 0; // loop_cnt
14342 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
14343 device_param->kernel_params_buf32[28] = 0; // digests_cnt
14344 device_param->kernel_params_buf32[29] = 0; // digests_offset
14345 device_param->kernel_params_buf32[30] = 0; // combs_mode
14346 device_param->kernel_params_buf32[31] = 0; // gid_max
14347
14348 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14349 ? &device_param->d_pws_buf
14350 : &device_param->d_pws_amp_buf;
14351 device_param->kernel_params[ 1] = &device_param->d_rules_c;
14352 device_param->kernel_params[ 2] = &device_param->d_combs_c;
14353 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
14354 device_param->kernel_params[ 4] = &device_param->d_tmps;
14355 device_param->kernel_params[ 5] = &device_param->d_hooks;
14356 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
14357 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
14358 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
14359 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
14360 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
14361 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
14362 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
14363 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
14364 device_param->kernel_params[14] = &device_param->d_plain_bufs;
14365 device_param->kernel_params[15] = &device_param->d_digests_buf;
14366 device_param->kernel_params[16] = &device_param->d_digests_shown;
14367 device_param->kernel_params[17] = &device_param->d_salt_bufs;
14368 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
14369 device_param->kernel_params[19] = &device_param->d_result;
14370 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
14371 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
14372 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
14373 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
14374 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
14375 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
14376 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
14377 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
14378 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
14379 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
14380 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
14381 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
14382
14383 device_param->kernel_params_mp_buf64[3] = 0;
14384 device_param->kernel_params_mp_buf32[4] = 0;
14385 device_param->kernel_params_mp_buf32[5] = 0;
14386 device_param->kernel_params_mp_buf32[6] = 0;
14387 device_param->kernel_params_mp_buf32[7] = 0;
14388 device_param->kernel_params_mp_buf32[8] = 0;
14389
14390 device_param->kernel_params_mp[0] = NULL;
14391 device_param->kernel_params_mp[1] = NULL;
14392 device_param->kernel_params_mp[2] = NULL;
14393 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
14394 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
14395 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
14396 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
14397 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
14398 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
14399
14400 device_param->kernel_params_mp_l_buf64[3] = 0;
14401 device_param->kernel_params_mp_l_buf32[4] = 0;
14402 device_param->kernel_params_mp_l_buf32[5] = 0;
14403 device_param->kernel_params_mp_l_buf32[6] = 0;
14404 device_param->kernel_params_mp_l_buf32[7] = 0;
14405 device_param->kernel_params_mp_l_buf32[8] = 0;
14406 device_param->kernel_params_mp_l_buf32[9] = 0;
14407
14408 device_param->kernel_params_mp_l[0] = NULL;
14409 device_param->kernel_params_mp_l[1] = NULL;
14410 device_param->kernel_params_mp_l[2] = NULL;
14411 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14412 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14413 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14414 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14415 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14416 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14417 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14418
14419 device_param->kernel_params_mp_r_buf64[3] = 0;
14420 device_param->kernel_params_mp_r_buf32[4] = 0;
14421 device_param->kernel_params_mp_r_buf32[5] = 0;
14422 device_param->kernel_params_mp_r_buf32[6] = 0;
14423 device_param->kernel_params_mp_r_buf32[7] = 0;
14424 device_param->kernel_params_mp_r_buf32[8] = 0;
14425
14426 device_param->kernel_params_mp_r[0] = NULL;
14427 device_param->kernel_params_mp_r[1] = NULL;
14428 device_param->kernel_params_mp_r[2] = NULL;
14429 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14430 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14431 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14432 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14433 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14434 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14435
14436 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14437 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14438
14439 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14440 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14441 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14442 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14443 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14444 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14445 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14446
14447 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14448 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14449
14450 /**
14451 * kernel name
14452 */
14453
14454 char kernel_name[64] = { 0 };
14455
14456 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14457 {
14458 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14459 {
14460 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14461
14462 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14463
14464 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14465
14466 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14467
14468 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14469
14470 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14471 }
14472 else
14473 {
14474 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14475
14476 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14477
14478 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14479
14480 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14481
14482 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14483
14484 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14485 }
14486
14487 if (data.attack_mode == ATTACK_MODE_BF)
14488 {
14489 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14490 {
14491 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14492
14493 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14494 }
14495 }
14496 }
14497 else
14498 {
14499 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14500
14501 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14502
14503 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14504
14505 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14506
14507 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14508
14509 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14510
14511 if (opts_type & OPTS_TYPE_HOOK12)
14512 {
14513 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14514
14515 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14516 }
14517
14518 if (opts_type & OPTS_TYPE_HOOK23)
14519 {
14520 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14521
14522 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14523 }
14524 }
14525
14526 for (uint i = 0; i <= 20; i++)
14527 {
14528 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14529 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14530 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14531
14532 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14533 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14534 }
14535
14536 for (uint i = 21; i <= 31; i++)
14537 {
14538 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14539 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14540 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14541
14542 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14543 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14544 }
14545
14546 if (attack_mode == ATTACK_MODE_BF)
14547 {
14548 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
14549 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
14550
14551 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14552 {
14553 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14554 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14555 }
14556 }
14557 else if (attack_mode == ATTACK_MODE_HYBRID1)
14558 {
14559 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14560 }
14561 else if (attack_mode == ATTACK_MODE_HYBRID2)
14562 {
14563 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14564 }
14565
14566 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14567 {
14568 // nothing to do
14569 }
14570 else
14571 {
14572 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
14573 }
14574
14575 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14576 {
14577 // nothing to do
14578 }
14579 else
14580 {
14581 for (uint i = 0; i < 5; i++)
14582 {
14583 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14584 }
14585
14586 for (uint i = 5; i < 7; i++)
14587 {
14588 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14589 }
14590 }
14591
14592 /**
14593 * Store initial fanspeed if gpu_temp_retain is enabled
14594 */
14595
14596 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
14597 int gpu_temp_retain_set = 0;
14598
14599 if (gpu_temp_disable == 0)
14600 {
14601 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14602 {
14603 hc_thread_mutex_lock (mux_adl);
14604
14605 if (data.hm_device[device_id].fan_supported == 1)
14606 {
14607 if (gpu_temp_retain_chgd == 0)
14608 {
14609 uint cur_temp = 0;
14610 uint default_temp = 0;
14611
14612 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);
14613
14614 if (ADL_rc == ADL_OK)
14615 {
14616 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14617
14618 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14619
14620 // special case with multi gpu setups: always use minimum retain
14621
14622 if (gpu_temp_retain_set == 0)
14623 {
14624 gpu_temp_retain = gpu_temp_retain_target;
14625 gpu_temp_retain_set = 1;
14626 }
14627 else
14628 {
14629 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14630 }
14631
14632 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14633 }
14634 }
14635
14636 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14637
14638 temp_retain_fanspeed_value[device_id] = fan_speed;
14639
14640 if (fan_speed == -1)
14641 {
14642 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14643
14644 temp_retain_fanspeed_value[device_id] = 0;
14645 }
14646 }
14647
14648 hc_thread_mutex_unlock (mux_adl);
14649 }
14650 }
14651
14652 /**
14653 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14654 */
14655
14656 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14657 {
14658 hc_thread_mutex_lock (mux_adl);
14659
14660 if (data.hm_device[device_id].od_version == 6)
14661 {
14662 int ADL_rc;
14663
14664 // check powertune capabilities first, if not available then skip device
14665
14666 int powertune_supported = 0;
14667
14668 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14669 {
14670 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14671
14672 return (-1);
14673 }
14674
14675 if (powertune_supported != 0)
14676 {
14677 // powercontrol settings
14678
14679 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14680
14681 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14682 {
14683 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14684 }
14685
14686 if (ADL_rc != ADL_OK)
14687 {
14688 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14689
14690 return (-1);
14691 }
14692
14693 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14694 {
14695 log_error ("ERROR: Failed to set new ADL PowerControl values");
14696
14697 return (-1);
14698 }
14699
14700 // clocks
14701
14702 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14703
14704 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14705
14706 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)
14707 {
14708 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14709
14710 return (-1);
14711 }
14712
14713 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14714
14715 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14716
14717 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14718 {
14719 log_error ("ERROR: Failed to get ADL device capabilities");
14720
14721 return (-1);
14722 }
14723
14724 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14725 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14726
14727 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14728 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14729
14730 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14731 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14732
14733 // warning if profile has too low max values
14734
14735 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14736 {
14737 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14738 }
14739
14740 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14741 {
14742 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14743 }
14744
14745 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14746
14747 performance_state->iNumberOfPerformanceLevels = 2;
14748
14749 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14750 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14751 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14752 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14753
14754 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)
14755 {
14756 log_info ("ERROR: Failed to set ADL performance state");
14757
14758 return (-1);
14759 }
14760
14761 local_free (performance_state);
14762 }
14763 }
14764
14765 hc_thread_mutex_unlock (mux_adl);
14766 }
14767 #endif // HAVE_HWMON && HAVE_ADL
14768 }
14769
14770 data.kernel_power_all = kernel_power_all;
14771
14772 if (data.quiet == 0) log_info ("");
14773
14774 /**
14775 * Inform user which algorithm is checked and at which workload setting
14776 */
14777
14778 if (benchmark == 1)
14779 {
14780 quiet = 0;
14781
14782 data.quiet = quiet;
14783
14784 char *hash_type = strhashtype (data.hash_mode); // not a bug
14785
14786 log_info ("Hashtype: %s", hash_type);
14787 log_info ("");
14788 }
14789
14790 /**
14791 * keep track of the progress
14792 */
14793
14794 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14795 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14796 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14797
14798 /**
14799 * open filehandles
14800 */
14801
14802 #if _WIN
14803 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14804 {
14805 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14806
14807 return (-1);
14808 }
14809
14810 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14811 {
14812 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14813
14814 return (-1);
14815 }
14816
14817 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14818 {
14819 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14820
14821 return (-1);
14822 }
14823 #endif
14824
14825 /**
14826 * dictionary pad
14827 */
14828
14829 segment_size *= (1024 * 1024);
14830
14831 data.segment_size = segment_size;
14832
14833 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14834
14835 wl_data->buf = (char *) mymalloc (segment_size);
14836 wl_data->avail = segment_size;
14837 wl_data->incr = segment_size;
14838 wl_data->cnt = 0;
14839 wl_data->pos = 0;
14840
14841 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14842
14843 data.wordlist_mode = wordlist_mode;
14844
14845 cs_t *css_buf = NULL;
14846 uint css_cnt = 0;
14847 uint dictcnt = 0;
14848 uint maskcnt = 1;
14849 char **masks = NULL;
14850 char **dictfiles = NULL;
14851
14852 uint mask_from_file = 0;
14853
14854 if (attack_mode == ATTACK_MODE_STRAIGHT)
14855 {
14856 if (wordlist_mode == WL_MODE_FILE)
14857 {
14858 int wls_left = myargc - (optind + 1);
14859
14860 for (int i = 0; i < wls_left; i++)
14861 {
14862 char *l0_filename = myargv[optind + 1 + i];
14863
14864 struct stat l0_stat;
14865
14866 if (stat (l0_filename, &l0_stat) == -1)
14867 {
14868 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14869
14870 return (-1);
14871 }
14872
14873 uint is_dir = S_ISDIR (l0_stat.st_mode);
14874
14875 if (is_dir == 0)
14876 {
14877 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14878
14879 dictcnt++;
14880
14881 dictfiles[dictcnt - 1] = l0_filename;
14882 }
14883 else
14884 {
14885 // do not allow --keyspace w/ a directory
14886
14887 if (keyspace == 1)
14888 {
14889 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14890
14891 return (-1);
14892 }
14893
14894 char **dictionary_files = NULL;
14895
14896 dictionary_files = scan_directory (l0_filename);
14897
14898 if (dictionary_files != NULL)
14899 {
14900 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14901
14902 for (int d = 0; dictionary_files[d] != NULL; d++)
14903 {
14904 char *l1_filename = dictionary_files[d];
14905
14906 struct stat l1_stat;
14907
14908 if (stat (l1_filename, &l1_stat) == -1)
14909 {
14910 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14911
14912 return (-1);
14913 }
14914
14915 if (S_ISREG (l1_stat.st_mode))
14916 {
14917 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14918
14919 dictcnt++;
14920
14921 dictfiles[dictcnt - 1] = strdup (l1_filename);
14922 }
14923 }
14924 }
14925
14926 local_free (dictionary_files);
14927 }
14928 }
14929
14930 if (dictcnt < 1)
14931 {
14932 log_error ("ERROR: No usable dictionary file found.");
14933
14934 return (-1);
14935 }
14936 }
14937 else if (wordlist_mode == WL_MODE_STDIN)
14938 {
14939 dictcnt = 1;
14940 }
14941 }
14942 else if (attack_mode == ATTACK_MODE_COMBI)
14943 {
14944 // display
14945
14946 char *dictfile1 = myargv[optind + 1 + 0];
14947 char *dictfile2 = myargv[optind + 1 + 1];
14948
14949 // find the bigger dictionary and use as base
14950
14951 FILE *fp1 = NULL;
14952 FILE *fp2 = NULL;
14953
14954 struct stat tmp_stat;
14955
14956 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14957 {
14958 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14959
14960 return (-1);
14961 }
14962
14963 if (stat (dictfile1, &tmp_stat) == -1)
14964 {
14965 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14966
14967 fclose (fp1);
14968
14969 return (-1);
14970 }
14971
14972 if (S_ISDIR (tmp_stat.st_mode))
14973 {
14974 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14975
14976 fclose (fp1);
14977
14978 return (-1);
14979 }
14980
14981 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14982 {
14983 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14984
14985 fclose (fp1);
14986
14987 return (-1);
14988 }
14989
14990 if (stat (dictfile2, &tmp_stat) == -1)
14991 {
14992 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14993
14994 fclose (fp1);
14995 fclose (fp2);
14996
14997 return (-1);
14998 }
14999
15000 if (S_ISDIR (tmp_stat.st_mode))
15001 {
15002 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
15003
15004 fclose (fp1);
15005 fclose (fp2);
15006
15007 return (-1);
15008 }
15009
15010 data.combs_cnt = 1;
15011
15012 data.quiet = 1;
15013
15014 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
15015
15016 data.quiet = quiet;
15017
15018 if (words1_cnt == 0)
15019 {
15020 log_error ("ERROR: %s: empty file", dictfile1);
15021
15022 fclose (fp1);
15023 fclose (fp2);
15024
15025 return (-1);
15026 }
15027
15028 data.combs_cnt = 1;
15029
15030 data.quiet = 1;
15031
15032 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
15033
15034 data.quiet = quiet;
15035
15036 if (words2_cnt == 0)
15037 {
15038 log_error ("ERROR: %s: empty file", dictfile2);
15039
15040 fclose (fp1);
15041 fclose (fp2);
15042
15043 return (-1);
15044 }
15045
15046 fclose (fp1);
15047 fclose (fp2);
15048
15049 data.dictfile = dictfile1;
15050 data.dictfile2 = dictfile2;
15051
15052 if (words1_cnt >= words2_cnt)
15053 {
15054 data.combs_cnt = words2_cnt;
15055 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15056
15057 dictfiles = &data.dictfile;
15058
15059 dictcnt = 1;
15060 }
15061 else
15062 {
15063 data.combs_cnt = words1_cnt;
15064 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15065
15066 dictfiles = &data.dictfile2;
15067
15068 dictcnt = 1;
15069
15070 // we also have to switch wordlist related rules!
15071
15072 char *tmpc = data.rule_buf_l;
15073
15074 data.rule_buf_l = data.rule_buf_r;
15075 data.rule_buf_r = tmpc;
15076
15077 int tmpi = data.rule_len_l;
15078
15079 data.rule_len_l = data.rule_len_r;
15080 data.rule_len_r = tmpi;
15081 }
15082 }
15083 else if (attack_mode == ATTACK_MODE_BF)
15084 {
15085 char *mask = NULL;
15086
15087 maskcnt = 0;
15088
15089 if (benchmark == 0)
15090 {
15091 mask = myargv[optind + 1];
15092
15093 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
15094
15095 if ((optind + 2) <= myargc)
15096 {
15097 struct stat file_stat;
15098
15099 if (stat (mask, &file_stat) == -1)
15100 {
15101 maskcnt = 1;
15102
15103 masks[maskcnt - 1] = mystrdup (mask);
15104 }
15105 else
15106 {
15107 int wls_left = myargc - (optind + 1);
15108
15109 uint masks_avail = INCR_MASKS;
15110
15111 for (int i = 0; i < wls_left; i++)
15112 {
15113 if (i != 0)
15114 {
15115 mask = myargv[optind + 1 + i];
15116
15117 if (stat (mask, &file_stat) == -1)
15118 {
15119 log_error ("ERROR: %s: %s", mask, strerror (errno));
15120
15121 return (-1);
15122 }
15123 }
15124
15125 uint is_file = S_ISREG (file_stat.st_mode);
15126
15127 if (is_file == 1)
15128 {
15129 FILE *mask_fp;
15130
15131 if ((mask_fp = fopen (mask, "r")) == NULL)
15132 {
15133 log_error ("ERROR: %s: %s", mask, strerror (errno));
15134
15135 return (-1);
15136 }
15137
15138 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15139
15140 while (!feof (mask_fp))
15141 {
15142 memset (line_buf, 0, HCBUFSIZ);
15143
15144 int line_len = fgetl (mask_fp, line_buf);
15145
15146 if (line_len == 0) continue;
15147
15148 if (line_buf[0] == '#') continue;
15149
15150 if (masks_avail == maskcnt)
15151 {
15152 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15153
15154 masks_avail += INCR_MASKS;
15155 }
15156
15157 masks[maskcnt] = mystrdup (line_buf);
15158
15159 maskcnt++;
15160 }
15161
15162 myfree (line_buf);
15163
15164 fclose (mask_fp);
15165 }
15166 else
15167 {
15168 log_error ("ERROR: %s: unsupported file-type", mask);
15169
15170 return (-1);
15171 }
15172 }
15173
15174 mask_from_file = 1;
15175 }
15176 }
15177 else
15178 {
15179 custom_charset_1 = (char *) "?l?d?u";
15180 custom_charset_2 = (char *) "?l?d";
15181 custom_charset_3 = (char *) "?l?d*!$@_";
15182
15183 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15184 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15185 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15186
15187 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
15188
15189 wordlist_mode = WL_MODE_MASK;
15190
15191 data.wordlist_mode = wordlist_mode;
15192
15193 increment = 1;
15194
15195 maskcnt = 1;
15196 }
15197 }
15198 else
15199 {
15200 /**
15201 * generate full masks and charsets
15202 */
15203
15204 masks = (char **) mymalloc (sizeof (char *));
15205
15206 switch (hash_mode)
15207 {
15208 case 1731: pw_min = 5;
15209 pw_max = 5;
15210 mask = mystrdup ("?b?b?b?b?b");
15211 break;
15212 case 12500: pw_min = 5;
15213 pw_max = 5;
15214 mask = mystrdup ("?b?b?b?b?b");
15215 break;
15216 default: pw_min = 7;
15217 pw_max = 7;
15218 mask = mystrdup ("?b?b?b?b?b?b?b");
15219 break;
15220 }
15221
15222 maskcnt = 1;
15223
15224 masks[maskcnt - 1] = mystrdup (mask);
15225
15226 wordlist_mode = WL_MODE_MASK;
15227
15228 data.wordlist_mode = wordlist_mode;
15229
15230 increment = 1;
15231 }
15232
15233 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
15234
15235 if (increment)
15236 {
15237 if (increment_min > pw_min) pw_min = increment_min;
15238
15239 if (increment_max < pw_max) pw_max = increment_max;
15240 }
15241 }
15242 else if (attack_mode == ATTACK_MODE_HYBRID1)
15243 {
15244 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15245
15246 // display
15247
15248 char *mask = myargv[myargc - 1];
15249
15250 maskcnt = 0;
15251
15252 masks = (char **) mymalloc (1 * sizeof (char *));
15253
15254 // mod
15255
15256 struct stat file_stat;
15257
15258 if (stat (mask, &file_stat) == -1)
15259 {
15260 maskcnt = 1;
15261
15262 masks[maskcnt - 1] = mystrdup (mask);
15263 }
15264 else
15265 {
15266 uint is_file = S_ISREG (file_stat.st_mode);
15267
15268 if (is_file == 1)
15269 {
15270 FILE *mask_fp;
15271
15272 if ((mask_fp = fopen (mask, "r")) == NULL)
15273 {
15274 log_error ("ERROR: %s: %s", mask, strerror (errno));
15275
15276 return (-1);
15277 }
15278
15279 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15280
15281 uint masks_avail = 1;
15282
15283 while (!feof (mask_fp))
15284 {
15285 memset (line_buf, 0, HCBUFSIZ);
15286
15287 int line_len = fgetl (mask_fp, line_buf);
15288
15289 if (line_len == 0) continue;
15290
15291 if (line_buf[0] == '#') continue;
15292
15293 if (masks_avail == maskcnt)
15294 {
15295 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15296
15297 masks_avail += INCR_MASKS;
15298 }
15299
15300 masks[maskcnt] = mystrdup (line_buf);
15301
15302 maskcnt++;
15303 }
15304
15305 myfree (line_buf);
15306
15307 fclose (mask_fp);
15308
15309 mask_from_file = 1;
15310 }
15311 else
15312 {
15313 maskcnt = 1;
15314
15315 masks[maskcnt - 1] = mystrdup (mask);
15316 }
15317 }
15318
15319 // base
15320
15321 int wls_left = myargc - (optind + 2);
15322
15323 for (int i = 0; i < wls_left; i++)
15324 {
15325 char *filename = myargv[optind + 1 + i];
15326
15327 struct stat file_stat;
15328
15329 if (stat (filename, &file_stat) == -1)
15330 {
15331 log_error ("ERROR: %s: %s", filename, strerror (errno));
15332
15333 return (-1);
15334 }
15335
15336 uint is_dir = S_ISDIR (file_stat.st_mode);
15337
15338 if (is_dir == 0)
15339 {
15340 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15341
15342 dictcnt++;
15343
15344 dictfiles[dictcnt - 1] = filename;
15345 }
15346 else
15347 {
15348 // do not allow --keyspace w/ a directory
15349
15350 if (keyspace == 1)
15351 {
15352 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15353
15354 return (-1);
15355 }
15356
15357 char **dictionary_files = NULL;
15358
15359 dictionary_files = scan_directory (filename);
15360
15361 if (dictionary_files != NULL)
15362 {
15363 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15364
15365 for (int d = 0; dictionary_files[d] != NULL; d++)
15366 {
15367 char *l1_filename = dictionary_files[d];
15368
15369 struct stat l1_stat;
15370
15371 if (stat (l1_filename, &l1_stat) == -1)
15372 {
15373 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15374
15375 return (-1);
15376 }
15377
15378 if (S_ISREG (l1_stat.st_mode))
15379 {
15380 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15381
15382 dictcnt++;
15383
15384 dictfiles[dictcnt - 1] = strdup (l1_filename);
15385 }
15386 }
15387 }
15388
15389 local_free (dictionary_files);
15390 }
15391 }
15392
15393 if (dictcnt < 1)
15394 {
15395 log_error ("ERROR: No usable dictionary file found.");
15396
15397 return (-1);
15398 }
15399
15400 if (increment)
15401 {
15402 maskcnt = 0;
15403
15404 uint mask_min = increment_min; // we can't reject smaller masks here
15405 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15406
15407 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15408 {
15409 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15410
15411 if (cur_mask == NULL) break;
15412
15413 masks[maskcnt] = cur_mask;
15414
15415 maskcnt++;
15416
15417 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15418 }
15419 }
15420 }
15421 else if (attack_mode == ATTACK_MODE_HYBRID2)
15422 {
15423 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15424
15425 // display
15426
15427 char *mask = myargv[optind + 1 + 0];
15428
15429 maskcnt = 0;
15430
15431 masks = (char **) mymalloc (1 * sizeof (char *));
15432
15433 // mod
15434
15435 struct stat file_stat;
15436
15437 if (stat (mask, &file_stat) == -1)
15438 {
15439 maskcnt = 1;
15440
15441 masks[maskcnt - 1] = mystrdup (mask);
15442 }
15443 else
15444 {
15445 uint is_file = S_ISREG (file_stat.st_mode);
15446
15447 if (is_file == 1)
15448 {
15449 FILE *mask_fp;
15450
15451 if ((mask_fp = fopen (mask, "r")) == NULL)
15452 {
15453 log_error ("ERROR: %s: %s", mask, strerror (errno));
15454
15455 return (-1);
15456 }
15457
15458 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15459
15460 uint masks_avail = 1;
15461
15462 while (!feof (mask_fp))
15463 {
15464 memset (line_buf, 0, HCBUFSIZ);
15465
15466 int line_len = fgetl (mask_fp, line_buf);
15467
15468 if (line_len == 0) continue;
15469
15470 if (line_buf[0] == '#') continue;
15471
15472 if (masks_avail == maskcnt)
15473 {
15474 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15475
15476 masks_avail += INCR_MASKS;
15477 }
15478
15479 masks[maskcnt] = mystrdup (line_buf);
15480
15481 maskcnt++;
15482 }
15483
15484 myfree (line_buf);
15485
15486 fclose (mask_fp);
15487
15488 mask_from_file = 1;
15489 }
15490 else
15491 {
15492 maskcnt = 1;
15493
15494 masks[maskcnt - 1] = mystrdup (mask);
15495 }
15496 }
15497
15498 // base
15499
15500 int wls_left = myargc - (optind + 2);
15501
15502 for (int i = 0; i < wls_left; i++)
15503 {
15504 char *filename = myargv[optind + 2 + i];
15505
15506 struct stat file_stat;
15507
15508 if (stat (filename, &file_stat) == -1)
15509 {
15510 log_error ("ERROR: %s: %s", filename, strerror (errno));
15511
15512 return (-1);
15513 }
15514
15515 uint is_dir = S_ISDIR (file_stat.st_mode);
15516
15517 if (is_dir == 0)
15518 {
15519 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15520
15521 dictcnt++;
15522
15523 dictfiles[dictcnt - 1] = filename;
15524 }
15525 else
15526 {
15527 // do not allow --keyspace w/ a directory
15528
15529 if (keyspace == 1)
15530 {
15531 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15532
15533 return (-1);
15534 }
15535
15536 char **dictionary_files = NULL;
15537
15538 dictionary_files = scan_directory (filename);
15539
15540 if (dictionary_files != NULL)
15541 {
15542 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15543
15544 for (int d = 0; dictionary_files[d] != NULL; d++)
15545 {
15546 char *l1_filename = dictionary_files[d];
15547
15548 struct stat l1_stat;
15549
15550 if (stat (l1_filename, &l1_stat) == -1)
15551 {
15552 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15553
15554 return (-1);
15555 }
15556
15557 if (S_ISREG (l1_stat.st_mode))
15558 {
15559 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15560
15561 dictcnt++;
15562
15563 dictfiles[dictcnt - 1] = strdup (l1_filename);
15564 }
15565 }
15566 }
15567
15568 local_free (dictionary_files);
15569 }
15570 }
15571
15572 if (dictcnt < 1)
15573 {
15574 log_error ("ERROR: No usable dictionary file found.");
15575
15576 return (-1);
15577 }
15578
15579 if (increment)
15580 {
15581 maskcnt = 0;
15582
15583 uint mask_min = increment_min; // we can't reject smaller masks here
15584 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15585
15586 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15587 {
15588 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15589
15590 if (cur_mask == NULL) break;
15591
15592 masks[maskcnt] = cur_mask;
15593
15594 maskcnt++;
15595
15596 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15597 }
15598 }
15599 }
15600
15601 data.pw_min = pw_min;
15602 data.pw_max = pw_max;
15603
15604 /**
15605 * weak hash check
15606 */
15607
15608 if (weak_hash_threshold >= salts_cnt)
15609 {
15610 hc_device_param_t *device_param = NULL;
15611
15612 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15613 {
15614 device_param = &data.devices_param[device_id];
15615
15616 if (device_param->skipped) continue;
15617
15618 break;
15619 }
15620
15621 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15622
15623 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15624 {
15625 weak_hash_check (device_param, salt_pos);
15626 }
15627 }
15628
15629 // Display hack, guarantee that there is at least one \r before real start
15630
15631 if (data.quiet == 0) log_info_nn ("");
15632
15633 /**
15634 * status and monitor threads
15635 */
15636
15637 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15638
15639 hc_thread_t i_thread = 0;
15640
15641 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15642 {
15643 hc_thread_create (i_thread, thread_keypress, &benchmark);
15644 }
15645
15646 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15647
15648 uint ni_threads_cnt = 0;
15649
15650 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15651
15652 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15653
15654 ni_threads_cnt++;
15655
15656 /**
15657 * Outfile remove
15658 */
15659
15660 if (keyspace == 0)
15661 {
15662 if (outfile_check_timer != 0)
15663 {
15664 if (data.outfile_check_directory != NULL)
15665 {
15666 if ((hash_mode != 5200) &&
15667 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15668 (hash_mode != 9000))
15669 {
15670 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15671
15672 ni_threads_cnt++;
15673 }
15674 else
15675 {
15676 outfile_check_timer = 0;
15677 }
15678 }
15679 else
15680 {
15681 outfile_check_timer = 0;
15682 }
15683 }
15684 }
15685
15686 /**
15687 * Inform the user if we got some hashes remove because of the pot file remove feature
15688 */
15689
15690 if (data.quiet == 0)
15691 {
15692 if (potfile_remove_cracks > 0)
15693 {
15694 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15695 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15696 }
15697 }
15698
15699 data.outfile_check_timer = outfile_check_timer;
15700
15701 /**
15702 * main loop
15703 */
15704
15705 char **induction_dictionaries = NULL;
15706
15707 int induction_dictionaries_cnt = 0;
15708
15709 hcstat_table_t *root_table_buf = NULL;
15710 hcstat_table_t *markov_table_buf = NULL;
15711
15712 uint initial_restore_done = 0;
15713
15714 data.maskcnt = maskcnt;
15715
15716 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15717 {
15718 if (data.devices_status == STATUS_CRACKED) break;
15719
15720 data.devices_status = STATUS_INIT;
15721
15722 if (maskpos > rd->maskpos)
15723 {
15724 rd->dictpos = 0;
15725 }
15726
15727 rd->maskpos = maskpos;
15728 data.maskpos = maskpos;
15729
15730 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15731 {
15732 char *mask = masks[maskpos];
15733
15734 if (mask_from_file == 1)
15735 {
15736 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15737
15738 char *str_ptr;
15739 uint str_pos;
15740
15741 uint mask_offset = 0;
15742
15743 uint separator_cnt;
15744
15745 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15746 {
15747 str_ptr = strstr (mask + mask_offset, ",");
15748
15749 if (str_ptr == NULL) break;
15750
15751 str_pos = str_ptr - mask;
15752
15753 // escaped separator, i.e. "\,"
15754
15755 if (str_pos > 0)
15756 {
15757 if (mask[str_pos - 1] == '\\')
15758 {
15759 separator_cnt --;
15760
15761 mask_offset = str_pos + 1;
15762
15763 continue;
15764 }
15765 }
15766
15767 // reset the offset
15768
15769 mask_offset = 0;
15770
15771 mask[str_pos] = '\0';
15772
15773 switch (separator_cnt)
15774 {
15775 case 0:
15776 mp_reset_usr (mp_usr, 0);
15777
15778 custom_charset_1 = mask;
15779 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15780 break;
15781
15782 case 1:
15783 mp_reset_usr (mp_usr, 1);
15784
15785 custom_charset_2 = mask;
15786 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15787 break;
15788
15789 case 2:
15790 mp_reset_usr (mp_usr, 2);
15791
15792 custom_charset_3 = mask;
15793 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15794 break;
15795
15796 case 3:
15797 mp_reset_usr (mp_usr, 3);
15798
15799 custom_charset_4 = mask;
15800 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15801 break;
15802 }
15803
15804 mask = mask + str_pos + 1;
15805 }
15806 }
15807
15808 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15809 {
15810 if (maskpos > 0)
15811 {
15812 local_free (css_buf);
15813 local_free (data.root_css_buf);
15814 local_free (data.markov_css_buf);
15815
15816 local_free (masks[maskpos - 1]);
15817 }
15818
15819 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15820
15821 data.mask = mask;
15822 data.css_cnt = css_cnt;
15823 data.css_buf = css_buf;
15824
15825 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15826
15827 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15828
15829 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15830 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15831
15832 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15833
15834 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15835
15836 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15837 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15838
15839 data.root_css_buf = root_css_buf;
15840 data.markov_css_buf = markov_css_buf;
15841
15842 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15843
15844 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15845
15846 local_free (root_table_buf);
15847 local_free (markov_table_buf);
15848
15849 // args
15850
15851 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15852 {
15853 hc_device_param_t *device_param = &data.devices_param[device_id];
15854
15855 if (device_param->skipped) continue;
15856
15857 device_param->kernel_params_mp[0] = &device_param->d_combs;
15858 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15859 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15860
15861 device_param->kernel_params_mp_buf64[3] = 0;
15862 device_param->kernel_params_mp_buf32[4] = css_cnt;
15863 device_param->kernel_params_mp_buf32[5] = 0;
15864 device_param->kernel_params_mp_buf32[6] = 0;
15865 device_param->kernel_params_mp_buf32[7] = 0;
15866
15867 if (attack_mode == ATTACK_MODE_HYBRID1)
15868 {
15869 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15870 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15871 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15872 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15873 }
15874 else if (attack_mode == ATTACK_MODE_HYBRID2)
15875 {
15876 device_param->kernel_params_mp_buf32[5] = 0;
15877 device_param->kernel_params_mp_buf32[6] = 0;
15878 device_param->kernel_params_mp_buf32[7] = 0;
15879 }
15880
15881 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]);
15882 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]);
15883 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]);
15884
15885 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);
15886 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);
15887 }
15888 }
15889 else if (attack_mode == ATTACK_MODE_BF)
15890 {
15891 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15892
15893 if (increment)
15894 {
15895 for (uint i = 0; i < dictcnt; i++)
15896 {
15897 local_free (dictfiles[i]);
15898 }
15899
15900 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15901 {
15902 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15903
15904 if (l1_filename == NULL) break;
15905
15906 dictcnt++;
15907
15908 dictfiles[dictcnt - 1] = l1_filename;
15909 }
15910 }
15911 else
15912 {
15913 dictcnt++;
15914
15915 dictfiles[dictcnt - 1] = mask;
15916 }
15917
15918 if (dictcnt == 0)
15919 {
15920 log_error ("ERROR: Mask is too small");
15921
15922 return (-1);
15923 }
15924 }
15925 }
15926
15927 free (induction_dictionaries);
15928
15929 // induction_dictionaries_cnt = 0; // implied
15930
15931 if (attack_mode != ATTACK_MODE_BF)
15932 {
15933 if (keyspace == 0)
15934 {
15935 induction_dictionaries = scan_directory (induction_directory);
15936
15937 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15938 }
15939 }
15940
15941 if (induction_dictionaries_cnt)
15942 {
15943 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15944 }
15945
15946 /**
15947 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15948 */
15949 if (keyspace == 1)
15950 {
15951 if ((maskcnt > 1) || (dictcnt > 1))
15952 {
15953 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15954
15955 return (-1);
15956 }
15957 }
15958
15959 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15960 {
15961 char *subid = logfile_generate_subid ();
15962
15963 data.subid = subid;
15964
15965 logfile_sub_msg ("START");
15966
15967 data.devices_status = STATUS_INIT;
15968
15969 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
15970 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
15971 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
15972
15973 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15974
15975 data.cpt_pos = 0;
15976
15977 data.cpt_start = time (NULL);
15978
15979 data.cpt_total = 0;
15980
15981 if (data.restore == 0)
15982 {
15983 rd->words_cur = skip;
15984
15985 skip = 0;
15986
15987 data.skip = 0;
15988 }
15989
15990 data.ms_paused = 0;
15991
15992 data.words_cur = rd->words_cur;
15993
15994 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15995 {
15996 hc_device_param_t *device_param = &data.devices_param[device_id];
15997
15998 if (device_param->skipped) continue;
15999
16000 device_param->speed_pos = 0;
16001
16002 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
16003 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
16004 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
16005
16006 device_param->exec_pos = 0;
16007
16008 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
16009
16010 device_param->kernel_power = device_param->kernel_power_user;
16011
16012 device_param->outerloop_pos = 0;
16013 device_param->outerloop_left = 0;
16014 device_param->innerloop_pos = 0;
16015 device_param->innerloop_left = 0;
16016
16017 // some more resets:
16018
16019 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
16020
16021 device_param->pws_cnt = 0;
16022
16023 device_param->words_off = 0;
16024 device_param->words_done = 0;
16025 }
16026
16027 data.kernel_power_div = 0;
16028
16029 // figure out some workload
16030
16031 if (attack_mode == ATTACK_MODE_STRAIGHT)
16032 {
16033 if (data.wordlist_mode == WL_MODE_FILE)
16034 {
16035 char *dictfile = NULL;
16036
16037 if (induction_dictionaries_cnt)
16038 {
16039 dictfile = induction_dictionaries[0];
16040 }
16041 else
16042 {
16043 dictfile = dictfiles[dictpos];
16044 }
16045
16046 data.dictfile = dictfile;
16047
16048 logfile_sub_string (dictfile);
16049
16050 for (uint i = 0; i < rp_files_cnt; i++)
16051 {
16052 logfile_sub_var_string ("rulefile", rp_files[i]);
16053 }
16054
16055 FILE *fd2 = fopen (dictfile, "rb");
16056
16057 if (fd2 == NULL)
16058 {
16059 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16060
16061 return (-1);
16062 }
16063
16064 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16065
16066 fclose (fd2);
16067
16068 if (data.words_cnt == 0)
16069 {
16070 if (data.devices_status == STATUS_CRACKED) break;
16071 if (data.devices_status == STATUS_ABORTED) break;
16072
16073 dictpos++;
16074
16075 continue;
16076 }
16077 }
16078 }
16079 else if (attack_mode == ATTACK_MODE_COMBI)
16080 {
16081 char *dictfile = data.dictfile;
16082 char *dictfile2 = data.dictfile2;
16083
16084 logfile_sub_string (dictfile);
16085 logfile_sub_string (dictfile2);
16086
16087 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
16088 {
16089 FILE *fd2 = fopen (dictfile, "rb");
16090
16091 if (fd2 == NULL)
16092 {
16093 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16094
16095 return (-1);
16096 }
16097
16098 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16099
16100 fclose (fd2);
16101 }
16102 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
16103 {
16104 FILE *fd2 = fopen (dictfile2, "rb");
16105
16106 if (fd2 == NULL)
16107 {
16108 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16109
16110 return (-1);
16111 }
16112
16113 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
16114
16115 fclose (fd2);
16116 }
16117
16118 if (data.words_cnt == 0)
16119 {
16120 if (data.devices_status == STATUS_CRACKED) break;
16121 if (data.devices_status == STATUS_ABORTED) break;
16122
16123 dictpos++;
16124
16125 continue;
16126 }
16127 }
16128 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16129 {
16130 char *dictfile = NULL;
16131
16132 if (induction_dictionaries_cnt)
16133 {
16134 dictfile = induction_dictionaries[0];
16135 }
16136 else
16137 {
16138 dictfile = dictfiles[dictpos];
16139 }
16140
16141 data.dictfile = dictfile;
16142
16143 char *mask = data.mask;
16144
16145 logfile_sub_string (dictfile);
16146 logfile_sub_string (mask);
16147
16148 FILE *fd2 = fopen (dictfile, "rb");
16149
16150 if (fd2 == NULL)
16151 {
16152 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16153
16154 return (-1);
16155 }
16156
16157 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16158
16159 fclose (fd2);
16160
16161 if (data.words_cnt == 0)
16162 {
16163 if (data.devices_status == STATUS_CRACKED) break;
16164 if (data.devices_status == STATUS_ABORTED) break;
16165
16166 dictpos++;
16167
16168 continue;
16169 }
16170 }
16171 else if (attack_mode == ATTACK_MODE_BF)
16172 {
16173 local_free (css_buf);
16174 local_free (data.root_css_buf);
16175 local_free (data.markov_css_buf);
16176
16177 char *mask = dictfiles[dictpos];
16178
16179 logfile_sub_string (mask);
16180
16181 // base
16182
16183 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16184
16185 if (opts_type & OPTS_TYPE_PT_UNICODE)
16186 {
16187 uint css_cnt_unicode = css_cnt * 2;
16188
16189 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
16190
16191 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
16192 {
16193 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
16194
16195 css_buf_unicode[j + 1].cs_buf[0] = 0;
16196 css_buf_unicode[j + 1].cs_len = 1;
16197 }
16198
16199 free (css_buf);
16200
16201 css_buf = css_buf_unicode;
16202 css_cnt = css_cnt_unicode;
16203 }
16204
16205 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
16206
16207 uint mask_min = pw_min;
16208 uint mask_max = pw_max;
16209
16210 if (opts_type & OPTS_TYPE_PT_UNICODE)
16211 {
16212 mask_min *= 2;
16213 mask_max *= 2;
16214 }
16215
16216 if ((css_cnt < mask_min) || (css_cnt > mask_max))
16217 {
16218 if (css_cnt < mask_min)
16219 {
16220 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
16221 }
16222
16223 if (css_cnt > mask_max)
16224 {
16225 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
16226 }
16227
16228 // skip to next mask
16229
16230 dictpos++;
16231
16232 rd->dictpos = dictpos;
16233
16234 logfile_sub_msg ("STOP");
16235
16236 continue;
16237 }
16238
16239 uint save_css_cnt = css_cnt;
16240
16241 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16242 {
16243 if (opti_type & OPTI_TYPE_APPENDED_SALT)
16244 {
16245 uint salt_len = (uint) data.salts_buf[0].salt_len;
16246 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
16247
16248 uint css_cnt_salt = css_cnt + salt_len;
16249
16250 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
16251
16252 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
16253
16254 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
16255 {
16256 css_buf_salt[j].cs_buf[0] = salt_buf[i];
16257 css_buf_salt[j].cs_len = 1;
16258 }
16259
16260 free (css_buf);
16261
16262 css_buf = css_buf_salt;
16263 css_cnt = css_cnt_salt;
16264 }
16265 }
16266
16267 data.mask = mask;
16268 data.css_cnt = css_cnt;
16269 data.css_buf = css_buf;
16270
16271 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
16272
16273 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16274
16275 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16276
16277 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16278 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16279
16280 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16281
16282 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16283
16284 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16285 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16286
16287 data.root_css_buf = root_css_buf;
16288 data.markov_css_buf = markov_css_buf;
16289
16290 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16291
16292 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16293
16294 local_free (root_table_buf);
16295 local_free (markov_table_buf);
16296
16297 // copy + args
16298
16299 uint css_cnt_l = css_cnt;
16300 uint css_cnt_r;
16301
16302 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16303 {
16304 if (save_css_cnt < 6)
16305 {
16306 css_cnt_r = 1;
16307 }
16308 else if (save_css_cnt == 6)
16309 {
16310 css_cnt_r = 2;
16311 }
16312 else
16313 {
16314 if (opts_type & OPTS_TYPE_PT_UNICODE)
16315 {
16316 if (save_css_cnt == 8 || save_css_cnt == 10)
16317 {
16318 css_cnt_r = 2;
16319 }
16320 else
16321 {
16322 css_cnt_r = 4;
16323 }
16324 }
16325 else
16326 {
16327 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
16328 {
16329 css_cnt_r = 3;
16330 }
16331 else
16332 {
16333 css_cnt_r = 4;
16334 }
16335 }
16336 }
16337 }
16338 else
16339 {
16340 css_cnt_r = 1;
16341
16342 /* unfinished code?
16343 int sum = css_buf[css_cnt_r - 1].cs_len;
16344
16345 for (uint i = 1; i < 4 && i < css_cnt; i++)
16346 {
16347 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
16348
16349 css_cnt_r++;
16350
16351 sum *= css_buf[css_cnt_r - 1].cs_len;
16352 }
16353 */
16354 }
16355
16356 css_cnt_l -= css_cnt_r;
16357
16358 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
16359
16360 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16361 {
16362 hc_device_param_t *device_param = &data.devices_param[device_id];
16363
16364 if (device_param->skipped) continue;
16365
16366 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
16367 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
16368 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
16369
16370 device_param->kernel_params_mp_l_buf64[3] = 0;
16371 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
16372 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
16373 device_param->kernel_params_mp_l_buf32[6] = 0;
16374 device_param->kernel_params_mp_l_buf32[7] = 0;
16375 device_param->kernel_params_mp_l_buf32[8] = 0;
16376
16377 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
16378 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
16379 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
16380 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
16381
16382 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
16383 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
16384 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
16385
16386 device_param->kernel_params_mp_r_buf64[3] = 0;
16387 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
16388 device_param->kernel_params_mp_r_buf32[5] = 0;
16389 device_param->kernel_params_mp_r_buf32[6] = 0;
16390 device_param->kernel_params_mp_r_buf32[7] = 0;
16391
16392 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]);
16393 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]);
16394 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]);
16395
16396 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]);
16397 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]);
16398 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]);
16399
16400 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);
16401 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);
16402 }
16403 }
16404
16405 u64 words_base = data.words_cnt;
16406
16407 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16408 {
16409 if (data.kernel_rules_cnt)
16410 {
16411 words_base /= data.kernel_rules_cnt;
16412 }
16413 }
16414 else if (data.attack_kern == ATTACK_KERN_COMBI)
16415 {
16416 if (data.combs_cnt)
16417 {
16418 words_base /= data.combs_cnt;
16419 }
16420 }
16421 else if (data.attack_kern == ATTACK_KERN_BF)
16422 {
16423 if (data.bfs_cnt)
16424 {
16425 words_base /= data.bfs_cnt;
16426 }
16427 }
16428
16429 data.words_base = words_base;
16430
16431 if (keyspace == 1)
16432 {
16433 log_info ("%llu", (unsigned long long int) words_base);
16434
16435 return (0);
16436 }
16437
16438 if (data.words_cur > data.words_base)
16439 {
16440 log_error ("ERROR: restore value greater keyspace");
16441
16442 return (-1);
16443 }
16444
16445 if (data.words_cur)
16446 {
16447 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16448 {
16449 for (uint i = 0; i < data.salts_cnt; i++)
16450 {
16451 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16452 }
16453 }
16454 else if (data.attack_kern == ATTACK_KERN_COMBI)
16455 {
16456 for (uint i = 0; i < data.salts_cnt; i++)
16457 {
16458 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16459 }
16460 }
16461 else if (data.attack_kern == ATTACK_KERN_BF)
16462 {
16463 for (uint i = 0; i < data.salts_cnt; i++)
16464 {
16465 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16466 }
16467 }
16468 }
16469
16470 /*
16471 * Inform user about possible slow speeds
16472 */
16473
16474 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16475 {
16476 if (data.words_base < kernel_power_all)
16477 {
16478 if (quiet == 0)
16479 {
16480 log_info ("");
16481 log_info ("ATTENTION!");
16482 log_info (" The wordlist or mask you are using is too small.");
16483 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
16484 log_info (" The cracking speed will drop.");
16485 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16486 log_info ("");
16487 }
16488 }
16489 }
16490
16491 /*
16492 * Update loopback file
16493 */
16494
16495 if (loopback == 1)
16496 {
16497 time_t now;
16498
16499 time (&now);
16500
16501 uint random_num = get_random_num (0, 9999);
16502
16503 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16504
16505 data.loopback_file = loopback_file;
16506 }
16507
16508 /*
16509 * Update dictionary statistic
16510 */
16511
16512 if (keyspace == 0)
16513 {
16514 dictstat_fp = fopen (dictstat, "wb");
16515
16516 if (dictstat_fp)
16517 {
16518 lock_file (dictstat_fp);
16519
16520 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16521
16522 fclose (dictstat_fp);
16523 }
16524 }
16525
16526 data.devices_status = STATUS_RUNNING;
16527
16528 if (initial_restore_done == 0)
16529 {
16530 if (data.restore_disable == 0) cycle_restore ();
16531
16532 initial_restore_done = 1;
16533 }
16534
16535 hc_timer_set (&data.timer_running);
16536
16537 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16538 {
16539 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16540 {
16541 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16542 if (quiet == 0) fflush (stdout);
16543 }
16544 }
16545 else if (wordlist_mode == WL_MODE_STDIN)
16546 {
16547 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16548 if (data.quiet == 0) log_info ("");
16549 }
16550
16551 time_t runtime_start;
16552
16553 time (&runtime_start);
16554
16555 data.runtime_start = runtime_start;
16556
16557 /**
16558 * create cracker threads
16559 */
16560
16561 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
16562
16563 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16564 {
16565 hc_device_param_t *device_param = &devices_param[device_id];
16566
16567 if (wordlist_mode == WL_MODE_STDIN)
16568 {
16569 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16570 }
16571 else
16572 {
16573 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16574 }
16575 }
16576
16577 // wait for crack threads to exit
16578
16579 hc_thread_wait (data.devices_cnt, c_threads);
16580
16581 local_free (c_threads);
16582
16583 data.restore = 0;
16584
16585 // finalize task
16586
16587 logfile_sub_var_uint ("status-after-work", data.devices_status);
16588
16589 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16590
16591 if (data.devices_status == STATUS_CRACKED) break;
16592 if (data.devices_status == STATUS_ABORTED) break;
16593
16594 if (data.devices_status == STATUS_BYPASS)
16595 {
16596 data.devices_status = STATUS_RUNNING;
16597 }
16598
16599 if (induction_dictionaries_cnt)
16600 {
16601 unlink (induction_dictionaries[0]);
16602 }
16603
16604 free (induction_dictionaries);
16605
16606 if (attack_mode != ATTACK_MODE_BF)
16607 {
16608 induction_dictionaries = scan_directory (induction_directory);
16609
16610 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16611 }
16612
16613 if (benchmark == 0)
16614 {
16615 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16616 {
16617 if (quiet == 0) clear_prompt ();
16618
16619 if (quiet == 0) log_info ("");
16620
16621 if (status == 1)
16622 {
16623 status_display ();
16624 }
16625 else
16626 {
16627 if (quiet == 0) status_display ();
16628 }
16629
16630 if (quiet == 0) log_info ("");
16631 }
16632 }
16633
16634 if (attack_mode == ATTACK_MODE_BF)
16635 {
16636 dictpos++;
16637
16638 rd->dictpos = dictpos;
16639 }
16640 else
16641 {
16642 if (induction_dictionaries_cnt)
16643 {
16644 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16645 }
16646 else
16647 {
16648 dictpos++;
16649
16650 rd->dictpos = dictpos;
16651 }
16652 }
16653
16654 time_t runtime_stop;
16655
16656 time (&runtime_stop);
16657
16658 data.runtime_stop = runtime_stop;
16659
16660 logfile_sub_uint (runtime_start);
16661 logfile_sub_uint (runtime_stop);
16662
16663 logfile_sub_msg ("STOP");
16664
16665 global_free (subid);
16666 }
16667
16668 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16669
16670 if (data.devices_status == STATUS_CRACKED) break;
16671 if (data.devices_status == STATUS_ABORTED) break;
16672 if (data.devices_status == STATUS_QUIT) break;
16673
16674 if (data.devices_status == STATUS_BYPASS)
16675 {
16676 data.devices_status = STATUS_RUNNING;
16677 }
16678 }
16679
16680 // 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
16681
16682 if (attack_mode == ATTACK_MODE_STRAIGHT)
16683 {
16684 if (data.wordlist_mode == WL_MODE_FILE)
16685 {
16686 if (data.dictfile == NULL)
16687 {
16688 if (dictfiles != NULL)
16689 {
16690 data.dictfile = dictfiles[0];
16691
16692 hc_timer_set (&data.timer_running);
16693 }
16694 }
16695 }
16696 }
16697 // NOTE: combi is okay because it is already set beforehand
16698 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16699 {
16700 if (data.dictfile == NULL)
16701 {
16702 if (dictfiles != NULL)
16703 {
16704 hc_timer_set (&data.timer_running);
16705
16706 data.dictfile = dictfiles[0];
16707 }
16708 }
16709 }
16710 else if (attack_mode == ATTACK_MODE_BF)
16711 {
16712 if (data.mask == NULL)
16713 {
16714 hc_timer_set (&data.timer_running);
16715
16716 data.mask = masks[0];
16717 }
16718 }
16719
16720 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16721 {
16722 data.devices_status = STATUS_EXHAUSTED;
16723 }
16724
16725 // if cracked / aborted remove last induction dictionary
16726
16727 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16728 {
16729 struct stat induct_stat;
16730
16731 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16732 {
16733 unlink (induction_dictionaries[file_pos]);
16734 }
16735 }
16736
16737 // wait for non-interactive threads
16738
16739 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16740 {
16741 hc_thread_wait (1, &ni_threads[thread_idx]);
16742 }
16743
16744 local_free (ni_threads);
16745
16746 // wait for interactive threads
16747
16748 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16749 {
16750 hc_thread_wait (1, &i_thread);
16751 }
16752
16753 // we dont need restore file anymore
16754 if (data.restore_disable == 0)
16755 {
16756 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16757 {
16758 unlink (eff_restore_file);
16759 unlink (new_restore_file);
16760 }
16761 else
16762 {
16763 cycle_restore ();
16764 }
16765 }
16766
16767 // finally save left hashes
16768
16769 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16770 {
16771 save_hash ();
16772 }
16773
16774 /**
16775 * Clean up
16776 */
16777
16778 if (benchmark == 1)
16779 {
16780 status_benchmark ();
16781
16782 log_info ("");
16783 }
16784 else
16785 {
16786 if (quiet == 0) clear_prompt ();
16787
16788 if (quiet == 0) log_info ("");
16789
16790 if (status == 1)
16791 {
16792 status_display ();
16793 }
16794 else
16795 {
16796 if (quiet == 0) status_display ();
16797 }
16798
16799 if (quiet == 0) log_info ("");
16800 }
16801
16802 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16803 {
16804 hc_device_param_t *device_param = &data.devices_param[device_id];
16805
16806 if (device_param->skipped) continue;
16807
16808 local_free (device_param->result);
16809
16810 local_free (device_param->combs_buf);
16811
16812 local_free (device_param->hooks_buf);
16813
16814 local_free (device_param->device_name);
16815
16816 local_free (device_param->device_name_chksum);
16817
16818 local_free (device_param->device_version);
16819
16820 local_free (device_param->driver_version);
16821
16822 if (device_param->pws_buf) myfree (device_param->pws_buf);
16823 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
16824 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
16825 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
16826 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
16827 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
16828 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
16829 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
16830 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
16831 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
16832 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
16833 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
16834 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
16835 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
16836 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
16837 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
16838 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
16839 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
16840 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
16841 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
16842 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
16843 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
16844 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
16845 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
16846 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
16847 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
16848 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
16849 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
16850 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
16851
16852 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
16853 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
16854 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
16855 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
16856 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
16857 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
16858 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
16859 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
16860 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
16861 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
16862
16863 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
16864 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
16865 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
16866
16867 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
16868 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
16869 }
16870
16871 // reset default fan speed
16872
16873 #ifdef HAVE_HWMON
16874 if (gpu_temp_disable == 0)
16875 {
16876 #ifdef HAVE_ADL
16877 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16878 {
16879 hc_thread_mutex_lock (mux_adl);
16880
16881 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16882 {
16883 hc_device_param_t *device_param = &data.devices_param[device_id];
16884
16885 if (device_param->skipped) continue;
16886
16887 if (data.hm_device[device_id].fan_supported == 1)
16888 {
16889 int fanspeed = temp_retain_fanspeed_value[device_id];
16890
16891 if (fanspeed == -1) continue;
16892
16893 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
16894
16895 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
16896 }
16897 }
16898
16899 hc_thread_mutex_unlock (mux_adl);
16900 }
16901 #endif // HAVE_ADL
16902 }
16903
16904 #ifdef HAVE_ADL
16905 // reset power tuning
16906
16907 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16908 {
16909 hc_thread_mutex_lock (mux_adl);
16910
16911 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16912 {
16913 hc_device_param_t *device_param = &data.devices_param[device_id];
16914
16915 if (device_param->skipped) continue;
16916
16917 if (data.hm_device[device_id].od_version == 6)
16918 {
16919 // check powertune capabilities first, if not available then skip device
16920
16921 int powertune_supported = 0;
16922
16923 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
16924 {
16925 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16926
16927 return (-1);
16928 }
16929
16930 if (powertune_supported != 0)
16931 {
16932 // powercontrol settings
16933
16934 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)
16935 {
16936 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16937
16938 return (-1);
16939 }
16940
16941 // clocks
16942
16943 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16944
16945 performance_state->iNumberOfPerformanceLevels = 2;
16946
16947 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
16948 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
16949 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
16950 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
16951
16952 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)
16953 {
16954 log_info ("ERROR: Failed to restore ADL performance state");
16955
16956 return (-1);
16957 }
16958
16959 local_free (performance_state);
16960 }
16961 }
16962 }
16963
16964 hc_thread_mutex_unlock (mux_adl);
16965 }
16966 #endif // HAVE_ADL
16967
16968 if (gpu_temp_disable == 0)
16969 {
16970 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
16971 if (data.hm_nv)
16972 {
16973 #if defined(LINUX) && defined(HAVE_NVML)
16974
16975 hm_NVML_nvmlShutdown (data.hm_nv);
16976
16977 nvml_close (data.hm_nv);
16978
16979 #elif defined(WIN) && (HAVE_NVAPI)
16980
16981 hm_NvAPI_Unload (data.hm_nv);
16982
16983 nvapi_close (data.hm_nv);
16984
16985 #endif
16986
16987 data.hm_nv = NULL;
16988 }
16989 #endif
16990
16991 #ifdef HAVE_ADL
16992 if (data.hm_amd)
16993 {
16994 hm_ADL_Main_Control_Destroy (data.hm_amd);
16995
16996 adl_close (data.hm_amd);
16997 data.hm_amd = NULL;
16998 }
16999 #endif
17000 }
17001 #endif // HAVE_HWMON
17002
17003 // free memory
17004
17005 local_free (masks);
17006
17007 local_free (dictstat_base);
17008
17009 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
17010 {
17011 pot_t *pot_ptr = &pot[pot_pos];
17012
17013 hash_t *hash = &pot_ptr->hash;
17014
17015 local_free (hash->digest);
17016
17017 if (isSalted)
17018 {
17019 local_free (hash->salt);
17020 }
17021 }
17022
17023 local_free (pot);
17024
17025 local_free (all_kernel_rules_cnt);
17026 local_free (all_kernel_rules_buf);
17027
17028 local_free (wl_data->buf);
17029 local_free (wl_data);
17030
17031 local_free (bitmap_s1_a);
17032 local_free (bitmap_s1_b);
17033 local_free (bitmap_s1_c);
17034 local_free (bitmap_s1_d);
17035 local_free (bitmap_s2_a);
17036 local_free (bitmap_s2_b);
17037 local_free (bitmap_s2_c);
17038 local_free (bitmap_s2_d);
17039
17040 #ifdef HAVE_HWMON
17041 local_free (temp_retain_fanspeed_value);
17042 #ifdef HAVE_ADL
17043 local_free (od_clock_mem_status);
17044 local_free (od_power_control_status);
17045 #endif // ADL
17046 #endif
17047
17048 global_free (devices_param);
17049
17050 global_free (kernel_rules_buf);
17051
17052 global_free (root_css_buf);
17053 global_free (markov_css_buf);
17054
17055 global_free (digests_buf);
17056 global_free (digests_shown);
17057 global_free (digests_shown_tmp);
17058
17059 global_free (salts_buf);
17060 global_free (salts_shown);
17061
17062 global_free (esalts_buf);
17063
17064 global_free (words_progress_done);
17065 global_free (words_progress_rejected);
17066 global_free (words_progress_restored);
17067
17068 if (pot_fp) fclose (pot_fp);
17069
17070 if (data.devices_status == STATUS_QUIT) break;
17071 }
17072
17073 // destroy others mutex
17074
17075 hc_thread_mutex_delete (mux_dispatcher);
17076 hc_thread_mutex_delete (mux_counter);
17077 hc_thread_mutex_delete (mux_display);
17078 hc_thread_mutex_delete (mux_adl);
17079
17080 // free memory
17081
17082 local_free (eff_restore_file);
17083 local_free (new_restore_file);
17084
17085 local_free (rd);
17086
17087 // tuning db
17088
17089 tuning_db_destroy (tuning_db);
17090
17091 // loopback
17092
17093 local_free (loopback_file);
17094
17095 if (loopback == 1) unlink (loopback_file);
17096
17097 // induction directory
17098
17099 if (induction_dir == NULL)
17100 {
17101 if (attack_mode != ATTACK_MODE_BF)
17102 {
17103 if (rmdir (induction_directory) == -1)
17104 {
17105 if (errno == ENOENT)
17106 {
17107 // good, we can ignore
17108 }
17109 else if (errno == ENOTEMPTY)
17110 {
17111 // good, we can ignore
17112 }
17113 else
17114 {
17115 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
17116
17117 return (-1);
17118 }
17119 }
17120
17121 local_free (induction_directory);
17122 }
17123 }
17124
17125 // outfile-check directory
17126
17127 if (outfile_check_dir == NULL)
17128 {
17129 if (rmdir (outfile_check_directory) == -1)
17130 {
17131 if (errno == ENOENT)
17132 {
17133 // good, we can ignore
17134 }
17135 else if (errno == ENOTEMPTY)
17136 {
17137 // good, we can ignore
17138 }
17139 else
17140 {
17141 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
17142
17143 return (-1);
17144 }
17145 }
17146
17147 local_free (outfile_check_directory);
17148 }
17149
17150 time_t proc_stop;
17151
17152 time (&proc_stop);
17153
17154 logfile_top_uint (proc_start);
17155 logfile_top_uint (proc_stop);
17156
17157 logfile_top_msg ("STOP");
17158
17159 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
17160 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
17161
17162 if (data.ocl) ocl_close (data.ocl);
17163
17164 if (data.devices_status == STATUS_ABORTED) return 2;
17165 if (data.devices_status == STATUS_QUIT) return 2;
17166 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
17167 if (data.devices_status == STATUS_EXHAUSTED) return 1;
17168 if (data.devices_status == STATUS_CRACKED) return 0;
17169
17170 return -1;
17171 }
Hashcat additions to support pwdhash