projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Revert "Zero pws_buf before reuse"
[hashcat.git] / src / oclHashcat.c
1 /**
2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
5 *
6 * License.....: MIT
7 */
8
9 #ifdef OSX
10 #include <stdio.h>
11 #endif
12
13 #include <common.h>
14 #include <shared.h>
15 #include <rp_kernel_on_cpu.h>
16 #include <getopt.h>
17
18 const char *PROGNAME = "oclHashcat";
19 const uint VERSION_BIN = 210;
20 const uint RESTORE_MIN = 210;
21
22 double TARGET_MS_PROFILE[3] = { 8, 16, 96 };
23
24 #define INCR_RULES 10000
25 #define INCR_SALTS 100000
26 #define INCR_MASKS 1000
27 #define INCR_POT 1000
28
29 #define USAGE 0
30 #define VERSION 0
31 #define QUIET 0
32 #define MARKOV_THRESHOLD 0
33 #define MARKOV_DISABLE 0
34 #define MARKOV_CLASSIC 0
35 #define BENCHMARK 0
36 #define BENCHMARK_REPEATS 2
37 #define RESTORE 0
38 #define RESTORE_TIMER 60
39 #define RESTORE_DISABLE 0
40 #define STATUS 0
41 #define STATUS_TIMER 10
42 #define STATUS_AUTOMAT 0
43 #define LOOPBACK 0
44 #define WEAK_HASH_THRESHOLD 100
45 #define SHOW 0
46 #define LEFT 0
47 #define USERNAME 0
48 #define REMOVE 0
49 #define REMOVE_TIMER 60
50 #define SKIP 0
51 #define LIMIT 0
52 #define KEYSPACE 0
53 #define POTFILE_DISABLE 0
54 #define DEBUG_MODE 0
55 #define RP_GEN 0
56 #define RP_GEN_FUNC_MIN 1
57 #define RP_GEN_FUNC_MAX 4
58 #define RP_GEN_SEED 0
59 #define RULE_BUF_L ":"
60 #define RULE_BUF_R ":"
61 #define FORCE 0
62 #define RUNTIME 0
63 #define HEX_CHARSET 0
64 #define HEX_SALT 0
65 #define HEX_WORDLIST 0
66 #define OUTFILE_FORMAT 3
67 #define OUTFILE_AUTOHEX 1
68 #define OUTFILE_CHECK_TIMER 5
69 #define ATTACK_MODE 0
70 #define HASH_MODE 0
71 #define SEGMENT_SIZE 32
72 #define INCREMENT 0
73 #define INCREMENT_MIN 1
74 #define INCREMENT_MAX PW_MAX
75 #define SEPARATOR ':'
76 #define BITMAP_MIN 16
77 #define BITMAP_MAX 24
78 #define GPU_TEMP_DISABLE 0
79 #define GPU_TEMP_ABORT 90
80 #define GPU_TEMP_RETAIN 80
81 #define WORKLOAD_PROFILE 2
82 #define KERNEL_ACCEL 0
83 #define KERNEL_LOOPS 0
84 #define KERNEL_RULES 1024
85 #define KERNEL_COMBS 1024
86 #define KERNEL_BFS 1024
87 #define KERNEL_THREADS 64
88 #define POWERTUNE_ENABLE 0
89 #define LOGFILE_DISABLE 0
90 #define SCRYPT_TMTO 0
91 #define OPENCL_VECTOR_WIDTH 0
92
93 #define WL_MODE_STDIN 1
94 #define WL_MODE_FILE 2
95 #define WL_MODE_MASK 3
96
97 #define HL_MODE_FILE 4
98 #define HL_MODE_ARG 5
99
100 #define HLFMT_HASHCAT 0
101 #define HLFMT_PWDUMP 1
102 #define HLFMT_PASSWD 2
103 #define HLFMT_SHADOW 3
104 #define HLFMT_DCC 4
105 #define HLFMT_DCC2 5
106 #define HLFMT_NETNTLM1 7
107 #define HLFMT_NETNTLM2 8
108 #define HLFMT_NSLDAP 9
109 #define HLFMT_NSLDAPS 10
110 #define HLFMTS_CNT 11
111
112 #define ATTACK_MODE_STRAIGHT 0
113 #define ATTACK_MODE_COMBI 1
114 #define ATTACK_MODE_TOGGLE 2
115 #define ATTACK_MODE_BF 3
116 #define ATTACK_MODE_PERM 4
117 #define ATTACK_MODE_TABLE 5
118 #define ATTACK_MODE_HYBRID1 6
119 #define ATTACK_MODE_HYBRID2 7
120 #define ATTACK_MODE_NONE 100
121
122 #define ATTACK_KERN_STRAIGHT 0
123 #define ATTACK_KERN_COMBI 1
124 #define ATTACK_KERN_BF 3
125 #define ATTACK_KERN_NONE 100
126
127 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
128 #define ATTACK_EXEC_INSIDE_KERNEL 11
129
130 #define COMBINATOR_MODE_BASE_LEFT 10001
131 #define COMBINATOR_MODE_BASE_RIGHT 10002
132
133 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
134 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
135
136 #define MAX_CUT_TRIES 4
137
138 #define MAX_DICTSTAT 10000
139
140 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 131
141
142 #define global_free(attr) \
143 { \
144 myfree ((void *) data.attr); \
145 \
146 data.attr = NULL; \
147 }
148
149 #define local_free(attr) \
150 { \
151 myfree ((void *) attr); \
152 \
153 attr = NULL; \
154 }
155
156 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
157 {
158 900,
159 0,
160 5100,
161 100,
162 1400,
163 10800,
164 1700,
165 5000,
166 10100,
167 6000,
168 6100,
169 6900,
170 11700,
171 11800,
172 400,
173 8900,
174 11900,
175 12000,
176 10900,
177 12100,
178 23,
179 2500,
180 5300,
181 5400,
182 5500,
183 5600,
184 7300,
185 7500,
186 13100,
187 8300,
188 11100,
189 11200,
190 11400,
191 121,
192 2611,
193 2711,
194 2811,
195 8400,
196 11,
197 2612,
198 7900,
199 21,
200 11000,
201 124,
202 10000,
203 3711,
204 7600,
205 12,
206 131,
207 132,
208 1731,
209 200,
210 300,
211 3100,
212 112,
213 12300,
214 8000,
215 141,
216 1441,
217 1600,
218 12600,
219 1421,
220 101,
221 111,
222 1711,
223 3000,
224 1000,
225 1100,
226 2100,
227 12800,
228 1500,
229 12400,
230 500,
231 3200,
232 7400,
233 1800,
234 122,
235 1722,
236 7100,
237 6300,
238 6700,
239 6400,
240 6500,
241 2400,
242 2410,
243 5700,
244 9200,
245 9300,
246 22,
247 501,
248 5800,
249 8100,
250 8500,
251 7200,
252 9900,
253 7700,
254 7800,
255 10300,
256 8600,
257 8700,
258 9100,
259 133,
260 11600,
261 12500,
262 13000,
263 6211,
264 6221,
265 6231,
266 6241,
267 8800,
268 12900,
269 12200,
270 9700,
271 9710,
272 9800,
273 9810,
274 9400,
275 9500,
276 9600,
277 10400,
278 10410,
279 10500,
280 10600,
281 10700,
282 9000,
283 5200,
284 6800,
285 6600,
286 8200,
287 11300,
288 12700
289 };
290
291 /**
292 * types
293 */
294
295 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
296
297 /**
298 * globals
299 */
300
301 static unsigned int full01 = 0x01010101;
302 static unsigned int full80 = 0x80808080;
303
304 int SUPPRESS_OUTPUT = 0;
305
306 hc_thread_mutex_t mux_adl;
307 hc_thread_mutex_t mux_counter;
308 hc_thread_mutex_t mux_dispatcher;
309 hc_thread_mutex_t mux_display;
310
311 hc_global_data_t data;
312
313 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
314
315 const char *USAGE_MINI[] =
316 {
317 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
318 "",
319 "Try --help for more help.",
320 NULL
321 };
322
323 const char *USAGE_BIG[] =
324 {
325 "%s, advanced password recovery",
326 "",
327 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
328 "",
329 "=======",
330 "Options",
331 "=======",
332 "",
333 "* General:",
334 "",
335 " -m, --hash-type=NUM Hash-type, see references below",
336 " -a, --attack-mode=NUM Attack-mode, see references below",
337 " -V, --version Print version",
338 " -h, --help Print help",
339 " --quiet Suppress output",
340 "",
341 "* Misc:",
342 "",
343 " --hex-charset Assume charset is given in hex",
344 " --hex-salt Assume salt is given in hex",
345 " --hex-wordlist Assume words in wordlist is given in hex",
346 " --force Ignore warnings",
347 " --status Enable automatic update of the status-screen",
348 " --status-timer=NUM Seconds between status-screen update",
349 " --status-automat Display the status view in a machine readable format",
350 " --loopback Add new plains to induct directory",
351 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
352 "",
353 "* Markov:",
354 "",
355 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
356 " --markov-disable Disables markov-chains, emulates classic brute-force",
357 " --markov-classic Enables classic markov-chains, no per-position enhancement",
358 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
359 "",
360 "* Session:",
361 "",
362 " --runtime=NUM Abort session after NUM seconds of runtime",
363 " --session=STR Define specific session name",
364 " --restore Restore session from --session",
365 " --restore-disable Do not write restore file",
366 "",
367 "* Files:",
368 "",
369 " -o, --outfile=FILE Define outfile for recovered hash",
370 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
371 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
372 " --outfile-check-timer=NUM Seconds between outfile checks",
373 " -p, --separator=CHAR Separator char for hashlists and outfile",
374 " --show Show cracked passwords only",
375 " --left Show un-cracked passwords only",
376 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
377 " --remove Enable remove of hash once it is cracked",
378 " --remove-timer=NUM Update input hash file each NUM seconds",
379 " --potfile-disable Do not write potfile",
380 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
381 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
382 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
383 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
384 " --logfile-disable Disable the logfile",
385 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
386 "",
387 "* Resources:",
388 "",
389 " -b, --benchmark Run benchmark",
390 " --benchmark-repeats=NUM Repeat the kernel on the device NUM times to increase benchmark accuracy",
391 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
392 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
393 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
394 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
395 " --opencl-platforms=STR OpenCL platforms to use, separate with comma",
396 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
397 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
398 " --opencl-vector-width=NUM OpenCL vector-width (either 1, 2, 4, 8 or 16), overrides value from device query",
399 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
400 " -n, --kernel-accel=NUM Workload tuning, increase the outer-loop step size",
401 " -u, --kernel-loops=NUM Workload tuning, increase the inner-loop step size",
402 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
403 #ifdef HAVE_HWMON
404 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
405 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
406 #ifdef HAVE_ADL
407 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
408 #endif
409 #endif
410 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
411 "",
412 "* Distributed:",
413 "",
414 " -s, --skip=NUM Skip number of words",
415 " -l, --limit=NUM Limit number of words",
416 " --keyspace Show keyspace base:mod values and quit",
417 "",
418 "* Rules:",
419 "",
420 " -j, --rule-left=RULE Single rule applied to each word from left dict",
421 " -k, --rule-right=RULE Single rule applied to each word from right dict",
422 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
423 " -g, --generate-rules=NUM Generate NUM random rules",
424 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
425 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
426 " --generate-rules-seed=NUM Force RNG seed to NUM",
427 "",
428 "* Custom charsets:",
429 "",
430 " -1, --custom-charset1=CS User-defined charsets",
431 " -2, --custom-charset2=CS Example:",
432 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
433 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
434 "",
435 "* Increment:",
436 "",
437 " -i, --increment Enable increment mode",
438 " --increment-min=NUM Start incrementing at NUM",
439 " --increment-max=NUM Stop incrementing at NUM",
440 "",
441 "==========",
442 "References",
443 "==========",
444 "",
445 "* Workload Profile:",
446 "",
447 " 1 = Interactive performance profile, kernel execution runtime to 8ms, lower latency desktop, lower speed",
448 " 2 = Default performance profile, kernel execution runtime to 16ms, economic setting",
449 " 3 = Headless performance profile, kernel execution runtime to 96ms, higher latency desktop, higher speed",
450 "",
451 "* OpenCL device-types:",
452 "",
453 " 1 = CPU devices",
454 " 2 = GPU devices",
455 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
456 "",
457 "* Outfile Formats:",
458 "",
459 " 1 = hash[:salt]",
460 " 2 = plain",
461 " 3 = hash[:salt]:plain",
462 " 4 = hex_plain",
463 " 5 = hash[:salt]:hex_plain",
464 " 6 = plain:hex_plain",
465 " 7 = hash[:salt]:plain:hex_plain",
466 " 8 = crackpos",
467 " 9 = hash[:salt]:crackpos",
468 " 10 = plain:crackpos",
469 " 11 = hash[:salt]:plain:crackpos",
470 " 12 = hex_plain:crackpos",
471 " 13 = hash[:salt]:hex_plain:crackpos",
472 " 14 = plain:hex_plain:crackpos",
473 " 15 = hash[:salt]:plain:hex_plain:crackpos",
474 "",
475 "* Debug mode output formats (for hybrid mode only, by using rules):",
476 "",
477 " 1 = save finding rule",
478 " 2 = save original word",
479 " 3 = save original word and finding rule",
480 " 4 = save original word, finding rule and modified plain",
481 "",
482 "* Built-in charsets:",
483 "",
484 " ?l = abcdefghijklmnopqrstuvwxyz",
485 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
486 " ?d = 0123456789",
487 " ?s = !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
488 " ?a = ?l?u?d?s",
489 " ?b = 0x00 - 0xff",
490 "",
491 "* Attack modes:",
492 "",
493 " 0 = Straight",
494 " 1 = Combination",
495 " 3 = Brute-force",
496 " 6 = Hybrid dict + mask",
497 " 7 = Hybrid mask + dict",
498 "",
499 "* Hash types:",
500 "",
501 "[[ Roll-your-own: Raw Hashes ]]",
502 "",
503 " 900 = MD4",
504 " 0 = MD5",
505 " 5100 = Half MD5",
506 " 100 = SHA1",
507 " 10800 = SHA-384",
508 " 1400 = SHA-256",
509 " 1700 = SHA-512",
510 " 5000 = SHA-3(Keccak)",
511 " 10100 = SipHash",
512 " 6000 = RipeMD160",
513 " 6100 = Whirlpool",
514 " 6900 = GOST R 34.11-94",
515 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
516 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
517 "",
518 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
519 "",
520 " 10 = md5($pass.$salt)",
521 " 20 = md5($salt.$pass)",
522 " 30 = md5(unicode($pass).$salt)",
523 " 40 = md5($salt.unicode($pass))",
524 " 3800 = md5($salt.$pass.$salt)",
525 " 3710 = md5($salt.md5($pass))",
526 " 2600 = md5(md5($pass)",
527 " 4300 = md5(strtoupper(md5($pass)))",
528 " 4400 = md5(sha1($pass))",
529 " 110 = sha1($pass.$salt)",
530 " 120 = sha1($salt.$pass)",
531 " 130 = sha1(unicode($pass).$salt)",
532 " 140 = sha1($salt.unicode($pass))",
533 " 4500 = sha1(sha1($pass)",
534 " 4700 = sha1(md5($pass))",
535 " 4900 = sha1($salt.$pass.$salt)",
536 " 1410 = sha256($pass.$salt)",
537 " 1420 = sha256($salt.$pass)",
538 " 1430 = sha256(unicode($pass).$salt)",
539 " 1440 = sha256($salt.unicode($pass))",
540 " 1710 = sha512($pass.$salt)",
541 " 1720 = sha512($salt.$pass)",
542 " 1730 = sha512(unicode($pass).$salt)",
543 " 1740 = sha512($salt.unicode($pass))",
544 "",
545 "[[ Roll-your-own: Authenticated Hashes ]]",
546 "",
547 " 50 = HMAC-MD5 (key = $pass)",
548 " 60 = HMAC-MD5 (key = $salt)",
549 " 150 = HMAC-SHA1 (key = $pass)",
550 " 160 = HMAC-SHA1 (key = $salt)",
551 " 1450 = HMAC-SHA256 (key = $pass)",
552 " 1460 = HMAC-SHA256 (key = $salt)",
553 " 1750 = HMAC-SHA512 (key = $pass)",
554 " 1760 = HMAC-SHA512 (key = $salt)",
555 "",
556 "[[ Generic KDF ]]",
557 "",
558 " 400 = phpass",
559 " 8900 = scrypt",
560 " 11900 = PBKDF2-HMAC-MD5",
561 " 12000 = PBKDF2-HMAC-SHA1",
562 " 10900 = PBKDF2-HMAC-SHA256",
563 " 12100 = PBKDF2-HMAC-SHA512",
564 "",
565 "[[ Network protocols, Challenge-Response ]]",
566 "",
567 " 23 = Skype",
568 " 2500 = WPA/WPA2",
569 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
570 " 5300 = IKE-PSK MD5",
571 " 5400 = IKE-PSK SHA1",
572 " 5500 = NetNTLMv1",
573 " 5500 = NetNTLMv1 + ESS",
574 " 5600 = NetNTLMv2",
575 " 7300 = IPMI2 RAKP HMAC-SHA1",
576 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
577 " 8300 = DNSSEC (NSEC3)",
578 " 10200 = Cram MD5",
579 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
580 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
581 " 11400 = SIP digest authentication (MD5)",
582 " 13100 = Kerberos 5 TGS-REP etype 23",
583 "",
584 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
585 "",
586 " 121 = SMF (Simple Machines Forum)",
587 " 400 = phpBB3",
588 " 2611 = vBulletin < v3.8.5",
589 " 2711 = vBulletin > v3.8.5",
590 " 2811 = MyBB",
591 " 2811 = IPB (Invison Power Board)",
592 " 8400 = WBB3 (Woltlab Burning Board)",
593 " 11 = Joomla < 2.5.18",
594 " 400 = Joomla > 2.5.18",
595 " 400 = Wordpress",
596 " 2612 = PHPS",
597 " 7900 = Drupal7",
598 " 21 = osCommerce",
599 " 21 = xt:Commerce",
600 " 11000 = PrestaShop",
601 " 124 = Django (SHA-1)",
602 " 10000 = Django (PBKDF2-SHA256)",
603 " 3711 = Mediawiki B type",
604 " 7600 = Redmine",
605 "",
606 "[[ Database Server ]]",
607 "",
608 " 12 = PostgreSQL",
609 " 131 = MSSQL(2000)",
610 " 132 = MSSQL(2005)",
611 " 1731 = MSSQL(2012)",
612 " 1731 = MSSQL(2014)",
613 " 200 = MySQL323",
614 " 300 = MySQL4.1/MySQL5",
615 " 3100 = Oracle H: Type (Oracle 7+)",
616 " 112 = Oracle S: Type (Oracle 11+)",
617 " 12300 = Oracle T: Type (Oracle 12+)",
618 " 8000 = Sybase ASE",
619 "",
620 "[[ HTTP, SMTP, LDAP Server ]]",
621 "",
622 " 141 = EPiServer 6.x < v4",
623 " 1441 = EPiServer 6.x > v4",
624 " 1600 = Apache $apr1$",
625 " 12600 = ColdFusion 10+",
626 " 1421 = hMailServer",
627 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
628 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
629 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
630 "",
631 "[[ Checksums ]]",
632 "",
633 " 11500 = CRC32",
634 "",
635 "[[ Operating-Systems ]]",
636 "",
637 " 3000 = LM",
638 " 1000 = NTLM",
639 " 1100 = Domain Cached Credentials (DCC), MS Cache",
640 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
641 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
642 " 1500 = descrypt, DES(Unix), Traditional DES",
643 " 12400 = BSDiCrypt, Extended DES",
644 " 500 = md5crypt $1$, MD5(Unix)",
645 " 3200 = bcrypt $2*$, Blowfish(Unix)",
646 " 7400 = sha256crypt $5$, SHA256(Unix)",
647 " 1800 = sha512crypt $6$, SHA512(Unix)",
648 " 122 = OSX v10.4",
649 " 122 = OSX v10.5",
650 " 122 = OSX v10.6",
651 " 1722 = OSX v10.7",
652 " 7100 = OSX v10.8",
653 " 7100 = OSX v10.9",
654 " 7100 = OSX v10.10",
655 " 6300 = AIX {smd5}",
656 " 6700 = AIX {ssha1}",
657 " 6400 = AIX {ssha256}",
658 " 6500 = AIX {ssha512}",
659 " 2400 = Cisco-PIX",
660 " 2410 = Cisco-ASA",
661 " 500 = Cisco-IOS $1$",
662 " 5700 = Cisco-IOS $4$",
663 " 9200 = Cisco-IOS $8$",
664 " 9300 = Cisco-IOS $9$",
665 " 22 = Juniper Netscreen/SSG (ScreenOS)",
666 " 501 = Juniper IVE",
667 " 5800 = Android PIN",
668 " 8100 = Citrix Netscaler",
669 " 8500 = RACF",
670 " 7200 = GRUB 2",
671 " 9900 = Radmin2",
672 "",
673 "[[ Enterprise Application Software (EAS) ]]",
674 "",
675 " 7700 = SAP CODVN B (BCODE)",
676 " 7800 = SAP CODVN F/G (PASSCODE)",
677 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
678 " 8600 = Lotus Notes/Domino 5",
679 " 8700 = Lotus Notes/Domino 6",
680 " 9100 = Lotus Notes/Domino 8",
681 " 133 = PeopleSoft",
682 "",
683 "[[ Archives ]]",
684 "",
685 " 11600 = 7-Zip",
686 " 12500 = RAR3-hp",
687 " 13000 = RAR5",
688 "",
689 "[[ Full-Disk encryptions (FDE) ]]",
690 "",
691 " 62XY = TrueCrypt 5.0+",
692 " X = 1 = PBKDF2-HMAC-RipeMD160",
693 " X = 2 = PBKDF2-HMAC-SHA512",
694 " X = 3 = PBKDF2-HMAC-Whirlpool",
695 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
696 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
697 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
698 " Y = 3 = XTS 1536 bit (Ciphers: All)",
699 " 8800 = Android FDE < v4.3",
700 " 12900 = Android FDE (Samsung DEK)",
701 " 12200 = eCryptfs",
702 "",
703 "[[ Documents ]]",
704 "",
705 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
706 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
707 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
708 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
709 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
710 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
711 " 9400 = MS Office 2007",
712 " 9500 = MS Office 2010",
713 " 9600 = MS Office 2013",
714 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
715 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
716 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
717 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
718 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
719 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
720 "",
721 "[[ Password Managers ]]",
722 "",
723 " 9000 = Password Safe v2",
724 " 5200 = Password Safe v3",
725 " 6800 = Lastpass",
726 " 6600 = 1Password, agilekeychain",
727 " 8200 = 1Password, cloudkeychain",
728 " 11300 = Bitcoin/Litecoin wallet.dat",
729 " 12700 = Blockchain, My Wallet",
730 "",
731 NULL
732 };
733
734 /**
735 * oclHashcat specific functions
736 */
737
738 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
739 {
740 int exec_pos = (int) device_param->exec_pos - last_num_entries;
741
742 if (exec_pos < 0) exec_pos += EXEC_CACHE;
743
744 double exec_ms_sum = 0;
745
746 int exec_ms_cnt = 0;
747
748 for (int i = 0; i < last_num_entries; i++)
749 {
750 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
751
752 if (exec_ms)
753 {
754 exec_ms_sum += exec_ms;
755
756 exec_ms_cnt++;
757 }
758 }
759
760 if (exec_ms_cnt == 0) return 0;
761
762 return exec_ms_sum / exec_ms_cnt;
763 }
764
765 void status_display_automat ()
766 {
767 FILE *out = stdout;
768
769 fprintf (out, "STATUS\t%u\t", data.devices_status);
770
771 /**
772 * speed new
773 */
774
775 fprintf (out, "SPEED\t");
776
777 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
778 {
779 hc_device_param_t *device_param = &data.devices_param[device_id];
780
781 if (device_param->skipped) continue;
782
783 u64 speed_cnt = 0;
784 float speed_ms = 0;
785
786 for (int i = 0; i < SPEED_CACHE; i++)
787 {
788 float rec_ms;
789
790 hc_timer_get (device_param->speed_rec[i], rec_ms);
791
792 if (rec_ms > SPEED_MAXAGE) continue;
793
794 speed_cnt += device_param->speed_cnt[i];
795 speed_ms += device_param->speed_ms[i];
796 }
797
798 speed_cnt /= SPEED_CACHE;
799 speed_ms /= SPEED_CACHE;
800
801 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
802 }
803
804 /**
805 * exec time
806 */
807
808 fprintf (out, "EXEC_RUNTIME\t");
809
810 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
811 {
812 hc_device_param_t *device_param = &data.devices_param[device_id];
813
814 if (device_param->skipped) continue;
815
816 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
817
818 fprintf (out, "%f\t", exec_ms_avg);
819 }
820
821 /**
822 * words_cur
823 */
824
825 u64 words_cur = get_lowest_words_done ();
826
827 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
828
829 /**
830 * counter
831 */
832
833 uint salts_left = data.salts_cnt - data.salts_done;
834
835 if (salts_left == 0) salts_left = 1;
836
837 u64 progress_total = data.words_cnt * salts_left;
838
839 u64 all_done = 0;
840 u64 all_rejected = 0;
841 u64 all_restored = 0;
842
843 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
844 {
845 if (salts_left > 1)
846 {
847 // otherwise the final cracked status shows 0/XXX progress
848
849 if (data.salts_shown[salt_pos] == 1) continue;
850 }
851
852 all_done += data.words_progress_done[salt_pos];
853 all_rejected += data.words_progress_rejected[salt_pos];
854 all_restored += data.words_progress_restored[salt_pos];
855 }
856
857 u64 progress_cur = all_restored + all_done + all_rejected;
858 u64 progress_end = progress_total;
859
860 u64 progress_skip = 0;
861
862 if (data.skip)
863 {
864 progress_skip = MIN (data.skip, data.words_base) * salts_left;
865
866 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
867 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
868 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
869 }
870
871 if (data.limit)
872 {
873 progress_end = MIN (data.limit, data.words_base) * salts_left;
874
875 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
876 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
877 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
878 }
879
880 u64 progress_cur_relative_skip = progress_cur - progress_skip;
881 u64 progress_end_relative_skip = progress_end - progress_skip;
882
883 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
884
885 /**
886 * cracks
887 */
888
889 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
890 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
891
892 /**
893 * temperature
894 */
895
896 #ifdef HAVE_HWMON
897 if (data.gpu_temp_disable == 0)
898 {
899 fprintf (out, "TEMP\t");
900
901 hc_thread_mutex_lock (mux_adl);
902
903 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
904 {
905 hc_device_param_t *device_param = &data.devices_param[device_id];
906
907 if (device_param->skipped) continue;
908
909 int temp = hm_get_temperature_with_device_id (device_id);
910
911 fprintf (out, "%d\t", temp);
912 }
913
914 hc_thread_mutex_unlock (mux_adl);
915 }
916 #endif // HAVE_HWMON
917
918 /**
919 * flush
920 */
921
922 #ifdef _WIN
923 fputc ('\r', out);
924 fputc ('\n', out);
925 #endif
926
927 #ifdef _POSIX
928 fputc ('\n', out);
929 #endif
930
931 fflush (out);
932 }
933
934 void status_display ()
935 {
936 if (data.devices_status == STATUS_INIT) return;
937 if (data.devices_status == STATUS_STARTING) return;
938 if (data.devices_status == STATUS_BYPASS) return;
939
940 if (data.status_automat == 1)
941 {
942 status_display_automat ();
943
944 return;
945 }
946
947 char tmp_buf[1000] = { 0 };
948
949 uint tmp_len = 0;
950
951 log_info ("Session.Name...: %s", data.session);
952
953 char *status_type = strstatus (data.devices_status);
954
955 uint hash_mode = data.hash_mode;
956
957 char *hash_type = strhashtype (hash_mode); // not a bug
958
959 log_info ("Status.........: %s", status_type);
960
961 /**
962 * show rules
963 */
964
965 if (data.rp_files_cnt)
966 {
967 uint i;
968
969 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
970 {
971 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
972 }
973
974 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
975
976 log_info ("Rules.Type.....: %s", tmp_buf);
977
978 tmp_len = 0;
979 }
980
981 if (data.rp_gen)
982 {
983 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
984
985 if (data.rp_gen_seed)
986 {
987 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
988 }
989 }
990
991 /**
992 * show input
993 */
994
995 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
996 {
997 if (data.wordlist_mode == WL_MODE_FILE)
998 {
999 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
1000 }
1001 else if (data.wordlist_mode == WL_MODE_STDIN)
1002 {
1003 log_info ("Input.Mode.....: Pipe");
1004 }
1005 }
1006 else if (data.attack_mode == ATTACK_MODE_COMBI)
1007 {
1008 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1009 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1010 }
1011 else if (data.attack_mode == ATTACK_MODE_BF)
1012 {
1013 char *mask = data.mask;
1014
1015 if (mask != NULL)
1016 {
1017 uint mask_len = data.css_cnt;
1018
1019 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1020
1021 if (mask_len > 0)
1022 {
1023 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1024 {
1025 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1026 {
1027 mask_len -= data.salts_buf[0].salt_len;
1028 }
1029 }
1030
1031 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1032
1033 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1034 }
1035
1036 if (data.maskcnt > 1)
1037 {
1038 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1039
1040 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1041 }
1042
1043 log_info ("Input.Mode.....: %s", tmp_buf);
1044 }
1045
1046 tmp_len = 0;
1047 }
1048 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1049 {
1050 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1051 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1052 }
1053 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1054 {
1055 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1056 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1057 }
1058
1059 if (data.digests_cnt == 1)
1060 {
1061 if (data.hash_mode == 2500)
1062 {
1063 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1064
1065 uint pke[25] = { 0 };
1066
1067 char *pke_ptr = (char *) pke;
1068
1069 for (uint i = 0; i < 25; i++)
1070 {
1071 pke[i] = byte_swap_32 (wpa->pke[i]);
1072 }
1073
1074 char mac1[6] = { 0 };
1075 char mac2[6] = { 0 };
1076
1077 memcpy (mac1, pke_ptr + 23, 6);
1078 memcpy (mac2, pke_ptr + 29, 6);
1079
1080 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1081 (char *) data.salts_buf[0].salt_buf,
1082 mac1[0] & 0xff,
1083 mac1[1] & 0xff,
1084 mac1[2] & 0xff,
1085 mac1[3] & 0xff,
1086 mac1[4] & 0xff,
1087 mac1[5] & 0xff,
1088 mac2[0] & 0xff,
1089 mac2[1] & 0xff,
1090 mac2[2] & 0xff,
1091 mac2[3] & 0xff,
1092 mac2[4] & 0xff,
1093 mac2[5] & 0xff);
1094 }
1095 else if (data.hash_mode == 5200)
1096 {
1097 log_info ("Hash.Target....: File (%s)", data.hashfile);
1098 }
1099 else if (data.hash_mode == 9000)
1100 {
1101 log_info ("Hash.Target....: File (%s)", data.hashfile);
1102 }
1103 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1104 {
1105 log_info ("Hash.Target....: File (%s)", data.hashfile);
1106 }
1107 else
1108 {
1109 char out_buf[4096] = { 0 };
1110
1111 ascii_digest (out_buf, 0, 0);
1112
1113 // limit length
1114 if (strlen (out_buf) > 40)
1115 {
1116 out_buf[41] = '.';
1117 out_buf[42] = '.';
1118 out_buf[43] = '.';
1119 out_buf[44] = 0;
1120 }
1121
1122 log_info ("Hash.Target....: %s", out_buf);
1123 }
1124 }
1125 else
1126 {
1127 if (data.hash_mode == 3000)
1128 {
1129 char out_buf1[4096] = { 0 };
1130 char out_buf2[4096] = { 0 };
1131
1132 ascii_digest (out_buf1, 0, 0);
1133 ascii_digest (out_buf2, 0, 1);
1134
1135 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1136 }
1137 else
1138 {
1139 log_info ("Hash.Target....: File (%s)", data.hashfile);
1140 }
1141 }
1142
1143 log_info ("Hash.Type......: %s", hash_type);
1144
1145 /**
1146 * speed new
1147 */
1148
1149 u64 speed_cnt[DEVICES_MAX] = { 0 };
1150 float speed_ms[DEVICES_MAX] = { 0 };
1151
1152 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1153 {
1154 hc_device_param_t *device_param = &data.devices_param[device_id];
1155
1156 if (device_param->skipped) continue;
1157
1158 // we need to clear values (set to 0) because in case the device does
1159 // not get new candidates it idles around but speed display would
1160 // show it as working.
1161 // if we instantly set it to 0 after reading it happens that the
1162 // speed can be shown as zero if the users refreshes too fast.
1163 // therefore, we add a timestamp when a stat was recorded and if its
1164 // too old we will not use it
1165
1166 speed_cnt[device_id] = 0;
1167 speed_ms[device_id] = 0;
1168
1169 for (int i = 0; i < SPEED_CACHE; i++)
1170 {
1171 float rec_ms;
1172
1173 hc_timer_get (device_param->speed_rec[i], rec_ms);
1174
1175 if (rec_ms > SPEED_MAXAGE) continue;
1176
1177 speed_cnt[device_id] += device_param->speed_cnt[i];
1178 speed_ms[device_id] += device_param->speed_ms[i];
1179 }
1180
1181 speed_cnt[device_id] /= SPEED_CACHE;
1182 speed_ms[device_id] /= SPEED_CACHE;
1183 }
1184
1185 float hashes_all_ms = 0;
1186
1187 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1188
1189 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1190 {
1191 hc_device_param_t *device_param = &data.devices_param[device_id];
1192
1193 if (device_param->skipped) continue;
1194
1195 hashes_dev_ms[device_id] = 0;
1196
1197 if (speed_ms[device_id])
1198 {
1199 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1200
1201 hashes_all_ms += hashes_dev_ms[device_id];
1202 }
1203 }
1204
1205 /**
1206 * exec time
1207 */
1208
1209 double exec_all_ms[DEVICES_MAX] = { 0 };
1210
1211 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1212 {
1213 hc_device_param_t *device_param = &data.devices_param[device_id];
1214
1215 if (device_param->skipped) continue;
1216
1217 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1218
1219 exec_all_ms[device_id] = exec_ms_avg;
1220 }
1221
1222 /**
1223 * timers
1224 */
1225
1226 float ms_running = 0;
1227
1228 hc_timer_get (data.timer_running, ms_running);
1229
1230 float ms_paused = data.ms_paused;
1231
1232 if (data.devices_status == STATUS_PAUSED)
1233 {
1234 float ms_paused_tmp = 0;
1235
1236 hc_timer_get (data.timer_paused, ms_paused_tmp);
1237
1238 ms_paused += ms_paused_tmp;
1239 }
1240
1241 #ifdef WIN
1242
1243 __time64_t sec_run = ms_running / 1000;
1244
1245 #else
1246
1247 time_t sec_run = ms_running / 1000;
1248
1249 #endif
1250
1251 if (sec_run)
1252 {
1253 char display_run[32] = { 0 };
1254
1255 struct tm tm_run;
1256
1257 struct tm *tmp = NULL;
1258
1259 #ifdef WIN
1260
1261 tmp = _gmtime64 (&sec_run);
1262
1263 #else
1264
1265 tmp = gmtime (&sec_run);
1266
1267 #endif
1268
1269 if (tmp != NULL)
1270 {
1271 memset (&tm_run, 0, sizeof (tm_run));
1272
1273 memcpy (&tm_run, tmp, sizeof (tm_run));
1274
1275 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1276
1277 char *start = ctime (&data.proc_start);
1278
1279 size_t start_len = strlen (start);
1280
1281 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1282 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1283
1284 log_info ("Time.Started...: %s (%s)", start, display_run);
1285 }
1286 }
1287 else
1288 {
1289 log_info ("Time.Started...: 0 secs");
1290 }
1291
1292 /**
1293 * counters
1294 */
1295
1296 uint salts_left = data.salts_cnt - data.salts_done;
1297
1298 if (salts_left == 0) salts_left = 1;
1299
1300 u64 progress_total = data.words_cnt * salts_left;
1301
1302 u64 all_done = 0;
1303 u64 all_rejected = 0;
1304 u64 all_restored = 0;
1305
1306 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1307 {
1308 if (salts_left > 1)
1309 {
1310 // otherwise the final cracked status shows 0/XXX progress
1311
1312 if (data.salts_shown[salt_pos] == 1) continue;
1313 }
1314
1315 all_done += data.words_progress_done[salt_pos];
1316 all_rejected += data.words_progress_rejected[salt_pos];
1317 all_restored += data.words_progress_restored[salt_pos];
1318 }
1319
1320 u64 progress_cur = all_restored + all_done + all_rejected;
1321 u64 progress_end = progress_total;
1322
1323 u64 progress_skip = 0;
1324
1325 if (data.skip)
1326 {
1327 progress_skip = MIN (data.skip, data.words_base) * salts_left;
1328
1329 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1330 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1331 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1332 }
1333
1334 if (data.limit)
1335 {
1336 progress_end = MIN (data.limit, data.words_base) * salts_left;
1337
1338 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1339 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1340 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1341 }
1342
1343 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1344 u64 progress_end_relative_skip = progress_end - progress_skip;
1345
1346 float speed_ms_real = ms_running - ms_paused;
1347 u64 speed_plains_real = all_done;
1348
1349 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1350 {
1351 if (data.devices_status != STATUS_CRACKED)
1352 {
1353 u64 words_per_ms = 0;
1354
1355 if (speed_plains_real && speed_ms_real)
1356 {
1357 words_per_ms = speed_plains_real / speed_ms_real;
1358 }
1359
1360 #ifdef WIN
1361 __time64_t sec_etc = 0;
1362 #else
1363 time_t sec_etc = 0;
1364 #endif
1365
1366 if (words_per_ms)
1367 {
1368 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1369
1370 u64 ms_left = progress_left_relative_skip / words_per_ms;
1371
1372 sec_etc = ms_left / 1000;
1373 }
1374
1375 if (sec_etc == 0)
1376 {
1377 log_info ("Time.Estimated.: 0 secs");
1378 }
1379 else if ((u64) sec_etc > ETC_MAX)
1380 {
1381 log_info ("Time.Estimated.: > 10 Years");
1382 }
1383 else
1384 {
1385 char display_etc[32] = { 0 };
1386
1387 struct tm tm_etc;
1388
1389 struct tm *tmp = NULL;
1390
1391 #ifdef WIN
1392
1393 tmp = _gmtime64 (&sec_etc);
1394
1395 #else
1396
1397 tmp = gmtime (&sec_etc);
1398
1399 #endif
1400
1401 if (tmp != NULL)
1402 {
1403 memset (&tm_etc, 0, sizeof (tm_etc));
1404
1405 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1406
1407 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1408
1409 time_t now;
1410
1411 time (&now);
1412
1413 now += sec_etc;
1414
1415 char *etc = ctime (&now);
1416
1417 size_t etc_len = strlen (etc);
1418
1419 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1420 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1421
1422 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1423 }
1424 }
1425 }
1426 }
1427
1428 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1429 {
1430 hc_device_param_t *device_param = &data.devices_param[device_id];
1431
1432 if (device_param->skipped) continue;
1433
1434 char display_dev_cur[16] = { 0 };
1435
1436 strncpy (display_dev_cur, "0.00", 4);
1437
1438 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1439
1440 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1441 }
1442
1443 char display_all_cur[16] = { 0 };
1444
1445 strncpy (display_all_cur, "0.00", 4);
1446
1447 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1448
1449 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1450
1451 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1452 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1453
1454 log_info ("Recovered......: %u/%u (%.2f%%) Digests, %u/%u (%.2f%%) Salts", data.digests_done, data.digests_cnt, digests_percent * 100, data.salts_done, data.salts_cnt, salts_percent * 100);
1455
1456 // crack-per-time
1457
1458 if (data.digests_cnt > 100)
1459 {
1460 time_t now = time (NULL);
1461
1462 int cpt_cur_min = 0;
1463 int cpt_cur_hour = 0;
1464 int cpt_cur_day = 0;
1465
1466 for (int i = 0; i < CPT_BUF; i++)
1467 {
1468 const uint cracked = data.cpt_buf[i].cracked;
1469 const time_t timestamp = data.cpt_buf[i].timestamp;
1470
1471 if ((timestamp + 60) > now)
1472 {
1473 cpt_cur_min += cracked;
1474 }
1475
1476 if ((timestamp + 3600) > now)
1477 {
1478 cpt_cur_hour += cracked;
1479 }
1480
1481 if ((timestamp + 86400) > now)
1482 {
1483 cpt_cur_day += cracked;
1484 }
1485 }
1486
1487 float cpt_avg_min = (float) data.cpt_total / ((speed_ms_real / 1000) / 60);
1488 float cpt_avg_hour = (float) data.cpt_total / ((speed_ms_real / 1000) / 3600);
1489 float cpt_avg_day = (float) data.cpt_total / ((speed_ms_real / 1000) / 86400);
1490
1491 if ((data.cpt_start + 86400) < now)
1492 {
1493 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1494 cpt_cur_min,
1495 cpt_cur_hour,
1496 cpt_cur_day,
1497 cpt_avg_min,
1498 cpt_avg_hour,
1499 cpt_avg_day);
1500 }
1501 else if ((data.cpt_start + 3600) < now)
1502 {
1503 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1504 cpt_cur_min,
1505 cpt_cur_hour,
1506 cpt_avg_min,
1507 cpt_avg_hour,
1508 cpt_avg_day);
1509 }
1510 else if ((data.cpt_start + 60) < now)
1511 {
1512 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1513 cpt_cur_min,
1514 cpt_avg_min,
1515 cpt_avg_hour,
1516 cpt_avg_day);
1517 }
1518 else
1519 {
1520 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1521 cpt_avg_min,
1522 cpt_avg_hour,
1523 cpt_avg_day);
1524 }
1525 }
1526
1527 // Restore point
1528
1529 u64 restore_point = get_lowest_words_done ();
1530
1531 u64 restore_total = data.words_base;
1532
1533 float percent_restore = 0;
1534
1535 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1536
1537 if (progress_end_relative_skip)
1538 {
1539 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1540 {
1541 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1542 float percent_rejected = 0.0;
1543
1544 if (progress_cur)
1545 {
1546 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1547 }
1548
1549 log_info ("Progress.......: %llu/%llu (%.02f%%)", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip, percent_finished * 100);
1550 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1551
1552 if (data.restore_disable == 0)
1553 {
1554 if (percent_finished != 1)
1555 {
1556 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1557 }
1558 }
1559 }
1560 }
1561 else
1562 {
1563 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1564 {
1565 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1566 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1567
1568 if (data.restore_disable == 0)
1569 {
1570 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1571 }
1572 }
1573 else
1574 {
1575 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1576 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1577
1578 // --restore not allowed if stdin is used -- really? why?
1579
1580 //if (data.restore_disable == 0)
1581 //{
1582 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1583 //}
1584 }
1585 }
1586
1587 #ifdef HAVE_HWMON
1588 if (data.gpu_temp_disable == 0)
1589 {
1590 hc_thread_mutex_lock (mux_adl);
1591
1592 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1593 {
1594 hc_device_param_t *device_param = &data.devices_param[device_id];
1595
1596 if (device_param->skipped) continue;
1597
1598 #define HM_STR_BUF_SIZE 255
1599
1600 if (data.hm_device[device_id].fan_supported == 1)
1601 {
1602 char utilization[HM_STR_BUF_SIZE] = { 0 };
1603 char temperature[HM_STR_BUF_SIZE] = { 0 };
1604 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1605
1606 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1607 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1608
1609 if (device_param->vendor_id == VENDOR_ID_AMD)
1610 {
1611 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1612 }
1613 else if (device_param->vendor_id == VENDOR_ID_NV)
1614 {
1615 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1616 }
1617
1618 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1619 }
1620 else
1621 {
1622 char utilization[HM_STR_BUF_SIZE] = { 0 };
1623 char temperature[HM_STR_BUF_SIZE] = { 0 };
1624
1625 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1626 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1627
1628 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1629 }
1630 }
1631
1632 hc_thread_mutex_unlock (mux_adl);
1633 }
1634 #endif // HAVE_HWMON
1635 }
1636
1637 static void status_benchmark ()
1638 {
1639 if (data.devices_status == STATUS_INIT) return;
1640 if (data.devices_status == STATUS_STARTING) return;
1641
1642 if (data.words_cnt == 0) return;
1643
1644 u64 speed_cnt[DEVICES_MAX] = { 0 };
1645 float speed_ms[DEVICES_MAX] = { 0 };
1646
1647 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1648 {
1649 hc_device_param_t *device_param = &data.devices_param[device_id];
1650
1651 if (device_param->skipped) continue;
1652
1653 speed_cnt[device_id] = 0;
1654 speed_ms[device_id] = 0;
1655
1656 for (int i = 0; i < SPEED_CACHE; i++)
1657 {
1658 speed_cnt[device_id] += device_param->speed_cnt[i];
1659 speed_ms[device_id] += device_param->speed_ms[i];
1660 }
1661
1662 speed_cnt[device_id] /= SPEED_CACHE;
1663 speed_ms[device_id] /= SPEED_CACHE;
1664 }
1665
1666 float hashes_all_ms = 0;
1667
1668 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1669
1670 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1671 {
1672 hc_device_param_t *device_param = &data.devices_param[device_id];
1673
1674 if (device_param->skipped) continue;
1675
1676 hashes_dev_ms[device_id] = 0;
1677
1678 if (speed_ms[device_id])
1679 {
1680 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1681
1682 hashes_all_ms += hashes_dev_ms[device_id];
1683 }
1684 }
1685
1686 /**
1687 * exec time
1688 */
1689
1690 double exec_all_ms[DEVICES_MAX] = { 0 };
1691
1692 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1693 {
1694 hc_device_param_t *device_param = &data.devices_param[device_id];
1695
1696 if (device_param->skipped) continue;
1697
1698 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1699
1700 exec_all_ms[device_id] = exec_ms_avg;
1701 }
1702
1703 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1704 {
1705 hc_device_param_t *device_param = &data.devices_param[device_id];
1706
1707 if (device_param->skipped) continue;
1708
1709 char display_dev_cur[16] = { 0 };
1710
1711 strncpy (display_dev_cur, "0.00", 4);
1712
1713 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1714
1715 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1716 }
1717
1718 char display_all_cur[16] = { 0 };
1719
1720 strncpy (display_all_cur, "0.00", 4);
1721
1722 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1723
1724 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1725 }
1726
1727 /**
1728 * oclHashcat -only- functions
1729 */
1730
1731 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1732 {
1733 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1734 {
1735 if (attack_kern == ATTACK_KERN_STRAIGHT)
1736 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1737 else if (attack_kern == ATTACK_KERN_COMBI)
1738 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1739 else if (attack_kern == ATTACK_KERN_BF)
1740 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1741 }
1742 else
1743 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1744 }
1745
1746 static void generate_cached_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1747 {
1748 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1749 {
1750 if (attack_kern == ATTACK_KERN_STRAIGHT)
1751 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1752 else if (attack_kern == ATTACK_KERN_COMBI)
1753 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1754 else if (attack_kern == ATTACK_KERN_BF)
1755 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1756 }
1757 else
1758 {
1759 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1760 }
1761 }
1762
1763 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1764 {
1765 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1766 {
1767 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1768 }
1769 else
1770 {
1771 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1772 }
1773 }
1774
1775 static void generate_cached_kernel_mp_filename (const uint opti_type, const uint opts_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1776 {
1777 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1778 {
1779 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1780 }
1781 else
1782 {
1783 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1784 }
1785 }
1786
1787 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1788 {
1789 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1790 }
1791
1792 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1793 {
1794 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1795 }
1796
1797 static uint convert_from_hex (char *line_buf, const uint line_len)
1798 {
1799 if (line_len & 1) return (line_len); // not in hex
1800
1801 if (data.hex_wordlist == 1)
1802 {
1803 uint i;
1804 uint j;
1805
1806 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1807 {
1808 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1809 }
1810
1811 memset (line_buf + i, 0, line_len - i);
1812
1813 return (i);
1814 }
1815 else if (line_len >= 6) // $HEX[] = 6
1816 {
1817 if (line_buf[0] != '$') return (line_len);
1818 if (line_buf[1] != 'H') return (line_len);
1819 if (line_buf[2] != 'E') return (line_len);
1820 if (line_buf[3] != 'X') return (line_len);
1821 if (line_buf[4] != '[') return (line_len);
1822 if (line_buf[line_len - 1] != ']') return (line_len);
1823
1824 uint i;
1825 uint j;
1826
1827 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1828 {
1829 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1830 }
1831
1832 memset (line_buf + i, 0, line_len - i);
1833
1834 return (i);
1835 }
1836
1837 return (line_len);
1838 }
1839
1840 static void clear_prompt ()
1841 {
1842 fputc ('\r', stdout);
1843
1844 for (size_t i = 0; i < strlen (PROMPT); i++)
1845 {
1846 fputc (' ', stdout);
1847 }
1848
1849 fputc ('\r', stdout);
1850
1851 fflush (stdout);
1852 }
1853
1854 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1855 {
1856 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, gidd * sizeof (pw_t), sizeof (pw_t), pw, 0, NULL, NULL);
1857 }
1858
1859 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1860 {
1861 char *outfile = data.outfile;
1862 uint quiet = data.quiet;
1863 FILE *pot_fp = data.pot_fp;
1864 uint loopback = data.loopback;
1865 uint debug_mode = data.debug_mode;
1866 char *debug_file = data.debug_file;
1867
1868 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1869 int debug_rule_len = 0; // -1 error
1870 uint debug_plain_len = 0;
1871
1872 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1873
1874 // hash
1875
1876 char out_buf[4096] = { 0 };
1877
1878 ascii_digest (out_buf, salt_pos, digest_pos);
1879
1880 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1881
1882 // plain
1883
1884 plain_t plain;
1885
1886 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, idx * sizeof (plain_t), sizeof (plain_t), &plain, 0, NULL, NULL);
1887
1888 uint gidvid = plain.gidvid;
1889 uint il_pos = plain.il_pos;
1890
1891 u64 crackpos = device_param->words_off;
1892
1893 uint plain_buf[16] = { 0 };
1894
1895 u8 *plain_ptr = (u8 *) plain_buf;
1896 unsigned int plain_len = 0;
1897
1898 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1899 {
1900 u64 gidd = gidvid;
1901 u64 gidm = 0;
1902
1903 pw_t pw;
1904
1905 gidd_to_pw_t (device_param, gidd, &pw);
1906
1907 for (int i = 0, j = gidm; i < 16; i++, j++)
1908 {
1909 plain_buf[i] = pw.i[j];
1910 }
1911
1912 plain_len = pw.pw_len;
1913
1914 const uint off = device_param->innerloop_pos + il_pos;
1915
1916 if (debug_mode > 0)
1917 {
1918 debug_rule_len = 0;
1919
1920 // save rule
1921 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1922 {
1923 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1924
1925 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1926 }
1927
1928 // save plain
1929 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1930 {
1931 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1932
1933 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1934
1935 debug_plain_len = plain_len;
1936 }
1937 }
1938
1939 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1940
1941 crackpos += gidvid;
1942 crackpos *= data.kernel_rules_cnt;
1943 crackpos += device_param->innerloop_pos + il_pos;
1944
1945 if (plain_len > data.pw_max) plain_len = data.pw_max;
1946 }
1947 else if (data.attack_mode == ATTACK_MODE_COMBI)
1948 {
1949 u64 gidd = gidvid;
1950 u64 gidm = 0;
1951
1952 pw_t pw;
1953
1954 gidd_to_pw_t (device_param, gidd, &pw);
1955
1956 for (int i = 0, j = gidm; i < 16; i++, j++)
1957 {
1958 plain_buf[i] = pw.i[j];
1959 }
1960
1961 plain_len = pw.pw_len;
1962
1963 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1964 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1965
1966 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1967 {
1968 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1969 }
1970 else
1971 {
1972 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1973
1974 memcpy (plain_ptr, comb_buf, comb_len);
1975 }
1976
1977 plain_len += comb_len;
1978
1979 crackpos += gidvid;
1980 crackpos *= data.combs_cnt;
1981 crackpos += device_param->innerloop_pos + il_pos;
1982
1983 if (data.pw_max != PW_DICTMAX1)
1984 {
1985 if (plain_len > data.pw_max) plain_len = data.pw_max;
1986 }
1987 }
1988 else if (data.attack_mode == ATTACK_MODE_BF)
1989 {
1990 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1991 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1992
1993 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1994 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1995
1996 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1997 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1998
1999 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2000 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2001
2002 plain_len = data.css_cnt;
2003
2004 crackpos += gidvid;
2005 crackpos *= data.bfs_cnt;
2006 crackpos += device_param->innerloop_pos + il_pos;
2007 }
2008 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2009 {
2010 u64 gidd = gidvid;
2011 u64 gidm = 0;
2012
2013 pw_t pw;
2014
2015 gidd_to_pw_t (device_param, gidd, &pw);
2016
2017 for (int i = 0, j = gidm; i < 16; i++, j++)
2018 {
2019 plain_buf[i] = pw.i[j];
2020 }
2021
2022 plain_len = pw.pw_len;
2023
2024 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2025
2026 uint start = 0;
2027 uint stop = device_param->kernel_params_mp_buf32[4];
2028
2029 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2030
2031 plain_len += start + stop;
2032
2033 crackpos += gidvid;
2034 crackpos *= data.combs_cnt;
2035 crackpos += device_param->innerloop_pos + il_pos;
2036
2037 if (data.pw_max != PW_DICTMAX1)
2038 {
2039 if (plain_len > data.pw_max) plain_len = data.pw_max;
2040 }
2041 }
2042 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2043 {
2044 u64 gidd = gidvid;
2045 u64 gidm = 0;
2046
2047 pw_t pw;
2048
2049 gidd_to_pw_t (device_param, gidd, &pw);
2050
2051 for (int i = 0, j = gidm; i < 16; i++, j++)
2052 {
2053 plain_buf[i] = pw.i[j];
2054 }
2055
2056 plain_len = pw.pw_len;
2057
2058 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2059
2060 uint start = 0;
2061 uint stop = device_param->kernel_params_mp_buf32[4];
2062
2063 memmove (plain_ptr + stop, plain_ptr, plain_len);
2064
2065 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2066
2067 plain_len += start + stop;
2068
2069 crackpos += gidvid;
2070 crackpos *= data.combs_cnt;
2071 crackpos += device_param->innerloop_pos + il_pos;
2072
2073 if (data.pw_max != PW_DICTMAX1)
2074 {
2075 if (plain_len > data.pw_max) plain_len = data.pw_max;
2076 }
2077 }
2078
2079 if (data.attack_mode == ATTACK_MODE_BF)
2080 {
2081 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2082 {
2083 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2084 {
2085 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2086 {
2087 plain_len = plain_len - data.salts_buf[0].salt_len;
2088 }
2089 }
2090
2091 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2092 {
2093 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2094 {
2095 plain_ptr[j] = plain_ptr[i];
2096 }
2097
2098 plain_len = plain_len / 2;
2099 }
2100 }
2101 }
2102
2103 // if enabled, update also the potfile
2104
2105 if (pot_fp)
2106 {
2107 lock_file (pot_fp);
2108
2109 fprintf (pot_fp, "%s:", out_buf);
2110
2111 format_plain (pot_fp, plain_ptr, plain_len, 1);
2112
2113 fputc ('\n', pot_fp);
2114
2115 fflush (pot_fp);
2116
2117 unlock_file (pot_fp);
2118 }
2119
2120 // outfile
2121
2122 FILE *out_fp = NULL;
2123
2124 if (outfile != NULL)
2125 {
2126 if ((out_fp = fopen (outfile, "ab")) == NULL)
2127 {
2128 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2129
2130 out_fp = stdout;
2131 }
2132 lock_file (out_fp);
2133 }
2134 else
2135 {
2136 out_fp = stdout;
2137
2138 if (quiet == 0) clear_prompt ();
2139 }
2140
2141 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2142
2143 if (outfile != NULL)
2144 {
2145 if (out_fp != stdout)
2146 {
2147 fclose (out_fp);
2148 }
2149 }
2150 else
2151 {
2152 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2153 {
2154 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2155 {
2156 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2157 if (quiet == 0) fflush (stdout);
2158 }
2159 }
2160 }
2161
2162 // loopback
2163
2164 if (loopback)
2165 {
2166 char *loopback_file = data.loopback_file;
2167
2168 FILE *fb_fp = NULL;
2169
2170 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2171 {
2172 lock_file (fb_fp);
2173
2174 format_plain (fb_fp, plain_ptr, plain_len, 1);
2175
2176 fputc ('\n', fb_fp);
2177
2178 fclose (fb_fp);
2179 }
2180 }
2181
2182 // (rule) debug mode
2183
2184 // the next check implies that:
2185 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2186 // - debug_mode > 0
2187
2188 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2189 {
2190 if (debug_rule_len < 0) debug_rule_len = 0;
2191
2192 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2193
2194 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2195
2196 if ((quiet == 0) && (debug_file == NULL))
2197 {
2198 fprintf (stdout, "%s", PROMPT);
2199 fflush (stdout);
2200 }
2201 }
2202 }
2203
2204 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2205 {
2206 salt_t *salt_buf = &data.salts_buf[salt_pos];
2207
2208 int found = 0;
2209
2210 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2211
2212 for (uint i = 0; i < KERNEL_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2213
2214 if (found == 1)
2215 {
2216 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2217
2218 log_info_nn ("");
2219
2220 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL);
2221
2222 uint cpt_cracked = 0;
2223
2224 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2225 {
2226 uint idx = salt_buf->digests_offset + digest_pos;
2227
2228 if (data.digests_shown_tmp[idx] == 0) continue;
2229
2230 if (data.digests_shown[idx] == 1) continue;
2231
2232 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2233 {
2234 data.digests_shown[idx] = 1;
2235
2236 data.digests_done++;
2237
2238 cpt_cracked++;
2239
2240 salt_buf->digests_done++;
2241
2242 if (salt_buf->digests_done == salt_buf->digests_cnt)
2243 {
2244 data.salts_shown[salt_pos] = 1;
2245
2246 data.salts_done++;
2247 }
2248 }
2249
2250 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2251
2252 check_hash (device_param, salt_pos, digest_pos);
2253 }
2254
2255 if (cpt_cracked > 0)
2256 {
2257 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2258 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2259
2260 data.cpt_pos++;
2261
2262 data.cpt_total += cpt_cracked;
2263
2264 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2265 }
2266
2267 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2268 {
2269 // we need to reset cracked state on the device
2270 // otherwise host thinks again and again the hash was cracked
2271 // and returns invalid password each time
2272
2273 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2274
2275 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL);
2276 }
2277
2278 memset (device_param->result, 0, device_param->size_results);
2279
2280 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2281 }
2282 }
2283
2284 static void save_hash ()
2285 {
2286 char *hashfile = data.hashfile;
2287
2288 char new_hashfile[256] = { 0 };
2289 char old_hashfile[256] = { 0 };
2290
2291 snprintf (new_hashfile, 255, "%s.new", hashfile);
2292 snprintf (old_hashfile, 255, "%s.old", hashfile);
2293
2294 unlink (new_hashfile);
2295
2296 char separator = data.separator;
2297
2298 FILE *fp = fopen (new_hashfile, "wb");
2299
2300 if (fp == NULL)
2301 {
2302 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2303
2304 exit (-1);
2305 }
2306
2307 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2308 {
2309 if (data.salts_shown[salt_pos] == 1) continue;
2310
2311 salt_t *salt_buf = &data.salts_buf[salt_pos];
2312
2313 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2314 {
2315 uint idx = salt_buf->digests_offset + digest_pos;
2316
2317 if (data.digests_shown[idx] == 1) continue;
2318
2319 if (data.hash_mode != 2500)
2320 {
2321 char out_buf[4096] = { 0 };
2322
2323 if (data.username == 1)
2324 {
2325 user_t *user = data.hash_info[idx]->user;
2326
2327 uint i;
2328
2329 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2330
2331 fputc (separator, fp);
2332 }
2333
2334 ascii_digest (out_buf, salt_pos, digest_pos);
2335
2336 fputs (out_buf, fp);
2337
2338 log_out (fp, "");
2339 }
2340 else
2341 {
2342 hccap_t hccap;
2343
2344 to_hccap_t (&hccap, salt_pos, digest_pos);
2345
2346 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2347 }
2348 }
2349 }
2350
2351 fflush (fp);
2352
2353 fclose (fp);
2354
2355 unlink (old_hashfile);
2356
2357 if (rename (hashfile, old_hashfile) != 0)
2358 {
2359 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2360
2361 exit (-1);
2362 }
2363
2364 unlink (hashfile);
2365
2366 if (rename (new_hashfile, hashfile) != 0)
2367 {
2368 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2369
2370 exit (-1);
2371 }
2372
2373 unlink (old_hashfile);
2374 }
2375
2376 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2377 {
2378 // function called only in case kernel_power_all > words_left
2379
2380 float kernel_power_div = (float) (total_left) / kernel_power_all;
2381
2382 kernel_power_div += kernel_power_div / 100;
2383
2384 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2385
2386 while (kernel_power_new < total_left)
2387 {
2388 kernel_power_div += kernel_power_div / 100;
2389
2390 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2391 }
2392
2393 if (data.quiet == 0)
2394 {
2395 clear_prompt ();
2396
2397 log_info ("");
2398
2399 log_info ("INFO: approaching final keyspace, workload adjusted");
2400
2401 log_info ("");
2402
2403 fprintf (stdout, "%s", PROMPT);
2404
2405 fflush (stdout);
2406 }
2407
2408 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2409
2410 return kernel_power_div;
2411 }
2412
2413 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2414 {
2415 uint num_elements = num;
2416
2417 device_param->kernel_params_buf32[30] = data.combs_mode;
2418 device_param->kernel_params_buf32[31] = num;
2419
2420 uint kernel_threads = device_param->kernel_threads;
2421
2422 while (num_elements % kernel_threads) num_elements++;
2423
2424 cl_kernel kernel = NULL;
2425
2426 switch (kern_run)
2427 {
2428 case KERN_RUN_1: kernel = device_param->kernel1; break;
2429 case KERN_RUN_12: kernel = device_param->kernel12; break;
2430 case KERN_RUN_2: kernel = device_param->kernel2; break;
2431 case KERN_RUN_23: kernel = device_param->kernel23; break;
2432 case KERN_RUN_3: kernel = device_param->kernel3; break;
2433 }
2434
2435 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2436 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2437 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2438 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2439 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2440 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2441 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2442 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2443 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2444 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2445 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2446
2447 hc_timer_t timer;
2448
2449 hc_timer_set (&timer);
2450
2451 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2452 {
2453 const size_t global_work_size[3] = { num_elements, 32, 1 };
2454 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2455
2456 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2457 }
2458 else
2459 {
2460 size_t workgroup_size = 0;
2461
2462 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2463
2464 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2465
2466 const size_t global_work_size[3] = { num_elements, 1, 1 };
2467 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2468
2469 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2470 }
2471
2472 hc_clFlush (data.ocl, device_param->command_queue);
2473
2474 hc_clFinish (data.ocl, device_param->command_queue);
2475
2476 if (event_update)
2477 {
2478 float exec_time;
2479
2480 hc_timer_get (timer, exec_time);
2481
2482 uint exec_pos = device_param->exec_pos;
2483
2484 device_param->exec_ms[exec_pos] = exec_time;
2485
2486 exec_pos++;
2487
2488 if (exec_pos == EXEC_CACHE)
2489 {
2490 exec_pos = 0;
2491 }
2492
2493 device_param->exec_pos = exec_pos;
2494 }
2495 }
2496
2497 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2498 {
2499 uint num_elements = num;
2500
2501 switch (kern_run)
2502 {
2503 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2504 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2505 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2506 }
2507
2508 // causes problems with special threads like in bcrypt
2509 // const uint kernel_threads = device_param->kernel_threads;
2510
2511 uint kernel_threads = KERNEL_THREADS;
2512
2513 while (num_elements % kernel_threads) num_elements++;
2514
2515 cl_kernel kernel = NULL;
2516
2517 switch (kern_run)
2518 {
2519 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2520 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2521 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2522 }
2523
2524 switch (kern_run)
2525 {
2526 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2527 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2528 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2529 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2530 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2531 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2532 break;
2533 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2534 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2535 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2536 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2537 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2538 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2539 break;
2540 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2541 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2542 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2543 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2544 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2545 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2546 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2547 break;
2548 }
2549
2550 size_t workgroup_size = 0;
2551 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), &workgroup_size, NULL);
2552 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2553
2554 const size_t global_work_size[3] = { num_elements, 1, 1 };
2555 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2556
2557 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2558
2559 hc_clFlush (data.ocl, device_param->command_queue);
2560
2561 hc_clFinish (data.ocl, device_param->command_queue);
2562 }
2563
2564 static void run_kernel_tb (hc_device_param_t *device_param, const uint num)
2565 {
2566 uint num_elements = num;
2567
2568 uint kernel_threads = device_param->kernel_threads;
2569
2570 while (num_elements % kernel_threads) num_elements++;
2571
2572 cl_kernel kernel = device_param->kernel_tb;
2573
2574 size_t workgroup_size = 0;
2575 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2576 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2577
2578 const size_t global_work_size[3] = { num_elements, 1, 1 };
2579 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2580
2581 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2582
2583 hc_clFlush (data.ocl, device_param->command_queue);
2584
2585 hc_clFinish (data.ocl, device_param->command_queue);
2586 }
2587
2588 static void run_kernel_tm (hc_device_param_t *device_param)
2589 {
2590 const uint num_elements = 1024; // fixed
2591
2592 uint kernel_threads = 32;
2593
2594 cl_kernel kernel = device_param->kernel_tm;
2595
2596 size_t workgroup_size = 0;
2597 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2598 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2599
2600 const size_t global_work_size[3] = { num_elements, 1, 1 };
2601 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2602
2603 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2604
2605 hc_clFlush (data.ocl, device_param->command_queue);
2606
2607 hc_clFinish (data.ocl, device_param->command_queue);
2608 }
2609
2610 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2611 {
2612 uint num_elements = num;
2613
2614 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2615 device_param->kernel_params_amp_buf32[6] = num_elements;
2616
2617 // causes problems with special threads like in bcrypt
2618 // const uint kernel_threads = device_param->kernel_threads;
2619
2620 uint kernel_threads = KERNEL_THREADS;
2621
2622 while (num_elements % kernel_threads) num_elements++;
2623
2624 cl_kernel kernel = device_param->kernel_amp;
2625
2626 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2627 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2628
2629 size_t workgroup_size = 0;
2630 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2631 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2632
2633 const size_t global_work_size[3] = { num_elements, 1, 1 };
2634 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2635
2636 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2637
2638 hc_clFlush (data.ocl, device_param->command_queue);
2639
2640 hc_clFinish (data.ocl, device_param->command_queue);
2641 }
2642
2643 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2644 {
2645 int rc = -1;
2646
2647 if (device_param->opencl_v12 && device_param->vendor_id == VENDOR_ID_AMD)
2648 {
2649 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2650
2651 const cl_uchar zero = 0;
2652
2653 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2654 }
2655
2656 if (rc != 0)
2657 {
2658 // NOTE: clEnqueueFillBuffer () always fails with -59
2659 // IOW, it's not supported by Nvidia ForceWare <= 352.21, also pocl segfaults, also on apple
2660 // How's that possible, OpenCL 1.2 support is advertised??
2661 // We need to workaround...
2662
2663 #define FILLSZ 0x100000
2664
2665 char *tmp = (char *) mymalloc (FILLSZ);
2666
2667 for (uint i = 0; i < size; i += FILLSZ)
2668 {
2669 const int left = size - i;
2670
2671 const int fillsz = MIN (FILLSZ, left);
2672
2673 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2674 }
2675
2676 myfree (tmp);
2677 }
2678 }
2679
2680 static void choose_kernel (hc_device_param_t *device_param, const uint attack_exec, const uint attack_mode, const uint opts_type, const salt_t *salt_buf, const uint highest_pw_len, const uint pws_cnt)
2681 {
2682 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2683 {
2684 if (attack_mode == ATTACK_MODE_BF)
2685 {
2686 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2687 {
2688 const uint size_tm = 32 * sizeof (bs_word_t);
2689
2690 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2691
2692 run_kernel_tm (device_param);
2693
2694 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_tm_c, device_param->d_bfs_c, 0, 0, size_tm, 0, NULL, NULL);
2695 }
2696 }
2697
2698 if (highest_pw_len < 16)
2699 {
2700 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2701 }
2702 else if (highest_pw_len < 32)
2703 {
2704 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2705 }
2706 else
2707 {
2708 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2709 }
2710 }
2711 else
2712 {
2713 run_kernel_amp (device_param, pws_cnt);
2714
2715 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2716
2717 if (opts_type & OPTS_TYPE_HOOK12)
2718 {
2719 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2720 }
2721
2722 uint iter = salt_buf->salt_iter;
2723
2724 uint loop_step = device_param->kernel_loops;
2725
2726 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2727 {
2728 uint loop_left = iter - loop_pos;
2729
2730 loop_left = MIN (loop_left, loop_step);
2731
2732 device_param->kernel_params_buf32[25] = loop_pos;
2733 device_param->kernel_params_buf32[26] = loop_left;
2734
2735 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2736
2737 if (data.devices_status == STATUS_CRACKED) break;
2738 if (data.devices_status == STATUS_ABORTED) break;
2739 if (data.devices_status == STATUS_QUIT) break;
2740 }
2741
2742 if (opts_type & OPTS_TYPE_HOOK23)
2743 {
2744 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2745
2746 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2747
2748 // do something with data
2749
2750 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2751 }
2752
2753 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2754 }
2755 }
2756
2757 static int run_rule_engine (const int rule_len, const char *rule_buf)
2758 {
2759 if (rule_len == 0)
2760 {
2761 return 0;
2762 }
2763 else if (rule_len == 1)
2764 {
2765 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2766 }
2767
2768 return 1;
2769 }
2770
2771 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2772 {
2773 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2774 {
2775 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2776 }
2777 else if (data.attack_kern == ATTACK_KERN_COMBI)
2778 {
2779 if (data.attack_mode == ATTACK_MODE_HYBRID2)
2780 {
2781 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2782 {
2783 for (u32 i = 0; i < pws_cnt; i++)
2784 {
2785 const u32 pw_len = device_param->pws_buf[i].pw_len;
2786
2787 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2788
2789 ptr[pw_len] = 0x01;
2790 }
2791 }
2792 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2793 {
2794 for (u32 i = 0; i < pws_cnt; i++)
2795 {
2796 const u32 pw_len = device_param->pws_buf[i].pw_len;
2797
2798 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2799
2800 ptr[pw_len] = 0x80;
2801 }
2802 }
2803 }
2804
2805 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);
2806 }
2807 else if (data.attack_kern == ATTACK_KERN_BF)
2808 {
2809 const u64 off = device_param->words_off;
2810
2811 device_param->kernel_params_mp_l_buf64[3] = off;
2812
2813 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2814 }
2815 }
2816
2817 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops, const int repeat)
2818 {
2819 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2820
2821 device_param->kernel_params_buf32[26] = kernel_loops;
2822 device_param->kernel_params_buf32[27] = kernel_loops;
2823
2824 // init some fake words
2825
2826 if (data.attack_kern == ATTACK_KERN_BF)
2827 {
2828 run_kernel_mp (KERN_RUN_MP_L, device_param, kernel_power);
2829 run_kernel_mp (KERN_RUN_MP_R, device_param, kernel_loops);
2830 }
2831 else
2832 {
2833 for (u32 i = 0; i < kernel_power; i++)
2834 {
2835 device_param->pws_buf[i].pw_len = i & 7;
2836 }
2837
2838 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, kernel_power * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2839
2840 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2841 {
2842 run_kernel_amp (device_param, kernel_power);
2843 }
2844 }
2845
2846 // caching run
2847
2848 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2849 {
2850 run_kernel (KERN_RUN_1, device_param, kernel_power, false);
2851 }
2852 else
2853 {
2854 run_kernel (KERN_RUN_2, device_param, kernel_power, false);
2855 }
2856
2857 // now user repeats
2858
2859 for (int i = 0; i < repeat; i++)
2860 {
2861 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2862 {
2863 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2864 }
2865 else
2866 {
2867 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2868 }
2869 }
2870
2871 const double exec_ms_prev = get_avg_exec_time (device_param, repeat);
2872
2873 // reset fake words
2874
2875 memset (device_param->pws_buf, 0, kernel_power * sizeof (pw_t));
2876
2877 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);
2878 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);
2879
2880 return exec_ms_prev;
2881 }
2882
2883 static void autotune (hc_device_param_t *device_param)
2884 {
2885 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2886
2887 const u32 kernel_accel_min = device_param->kernel_accel_min;
2888 const u32 kernel_accel_max = device_param->kernel_accel_max;
2889
2890 const u32 kernel_loops_min = device_param->kernel_loops_min;
2891 const u32 kernel_loops_max = device_param->kernel_loops_max;
2892
2893 u32 kernel_accel = kernel_accel_min;
2894 u32 kernel_loops = kernel_loops_min;
2895
2896 // steps
2897
2898 #define STEPS_CNT 10
2899
2900 #define STEPS_ACCEL_CNT (STEPS_CNT + 2)
2901 #define STEPS_LOOPS_CNT (STEPS_CNT + 2)
2902
2903 u32 steps_accel[STEPS_ACCEL_CNT];
2904 u32 steps_loops[STEPS_LOOPS_CNT];
2905
2906 for (int i = 0; i < STEPS_ACCEL_CNT; i++)
2907 {
2908 steps_accel[i] = 1 << i;
2909 }
2910
2911 for (int i = 0; i < STEPS_LOOPS_CNT; i++)
2912 {
2913 steps_loops[i] = 1 << i;
2914 }
2915
2916 steps_accel[STEPS_CNT + 0] = kernel_accel_min;
2917 steps_accel[STEPS_CNT + 1] = kernel_accel_max;
2918
2919 steps_loops[STEPS_CNT + 0] = kernel_loops_min;
2920 steps_loops[STEPS_CNT + 1] = kernel_loops_max;
2921
2922 qsort (steps_accel, STEPS_ACCEL_CNT, sizeof (u32), sort_by_u32);
2923 qsort (steps_loops, STEPS_LOOPS_CNT, sizeof (u32), sort_by_u32);
2924
2925 // find out highest kernel-loops that stays below target_ms, we can use it later for multiplication as this is a linear function
2926
2927 u32 kernel_loops_tmp;
2928
2929 for (kernel_loops_tmp = kernel_loops_max; kernel_loops_tmp > kernel_loops_min; kernel_loops_tmp >>= 1)
2930 {
2931 const double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops_tmp, 1);
2932
2933 if (exec_ms < target_ms) break;
2934 }
2935
2936 // kernel-accel
2937
2938 if (kernel_accel_min < kernel_accel_max)
2939 {
2940 double e_best = 0;
2941
2942 for (int i = 0; i < STEPS_ACCEL_CNT; i++)
2943 {
2944 const u32 kernel_accel_try = steps_accel[i];
2945
2946 if (kernel_accel_try < kernel_accel_min) continue;
2947 if (kernel_accel_try > kernel_accel_max) break;
2948
2949 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_tmp, 1);
2950
2951 if (exec_ms > target_ms) break;
2952
2953 const double e = kernel_accel_try / exec_ms;
2954
2955 if (e > e_best)
2956 {
2957 kernel_accel = kernel_accel_try;
2958
2959 e_best = e;
2960 }
2961 }
2962 }
2963
2964 // kernel-loops final
2965
2966 if (kernel_loops_min < kernel_loops_max)
2967 {
2968 double e_best = 0;
2969
2970 for (int i = 0; i < STEPS_LOOPS_CNT; i++)
2971 {
2972 const u32 kernel_loops_try = steps_loops[i];
2973
2974 if (kernel_loops_try < kernel_loops_min) continue;
2975 if (kernel_loops_try > kernel_loops_max) break;
2976
2977 const double exec_ms = try_run (device_param, kernel_accel, kernel_loops_try, 1);
2978
2979 if (exec_ms > target_ms) break;
2980
2981 const double e = kernel_loops_try / exec_ms;
2982
2983 if (e > e_best)
2984 {
2985 kernel_loops = kernel_loops_try;
2986
2987 e_best = e;
2988 }
2989 }
2990 }
2991
2992 // final balance
2993
2994 const double exec_ms = try_run (device_param, kernel_accel, kernel_loops, 1);
2995
2996 u32 kernel_accel_best = kernel_accel;
2997 u32 kernel_loops_best = kernel_loops;
2998
2999 u32 exec_best = exec_ms;
3000
3001 // reset
3002
3003 if (kernel_accel_min < kernel_accel_max)
3004 {
3005 u32 kernel_accel_try = kernel_accel;
3006 u32 kernel_loops_try = kernel_loops;
3007
3008 for (int i = 0; i < 2; i++)
3009 {
3010 kernel_accel_try >>= 1;
3011 kernel_loops_try <<= 1;
3012
3013 if (kernel_accel_try < kernel_accel_min) break;
3014 if (kernel_loops_try > kernel_loops_max) break;
3015
3016 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
3017
3018 if (exec_ms < exec_best)
3019 {
3020 kernel_accel_best = kernel_accel_try;
3021 kernel_loops_best = kernel_loops_try;
3022
3023 exec_best = exec_ms;
3024 }
3025 }
3026
3027 kernel_accel = kernel_accel_best;
3028 kernel_loops = kernel_loops_best;
3029 }
3030
3031 // reset
3032
3033
3034 if (kernel_loops_min < kernel_loops_max)
3035 {
3036 u32 kernel_accel_try = kernel_accel;
3037 u32 kernel_loops_try = kernel_loops;
3038
3039 for (int i = 0; i < 2; i++)
3040 {
3041 kernel_accel_try <<= 1;
3042 kernel_loops_try >>= 1;
3043
3044 if (kernel_accel_try > kernel_accel_max) break;
3045 if (kernel_loops_try < kernel_loops_min) break;
3046
3047 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
3048
3049 if (exec_ms < exec_best)
3050 {
3051 kernel_accel_best = kernel_accel_try;
3052 kernel_loops_best = kernel_loops_try;
3053
3054 exec_best = exec_ms;
3055 }
3056 }
3057
3058 kernel_accel = kernel_accel_best;
3059 kernel_loops = kernel_loops_best;
3060 }
3061
3062 // reset timer
3063
3064 device_param->exec_pos = 0;
3065
3066 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3067
3068 // store
3069
3070 device_param->kernel_loops = kernel_loops;
3071 device_param->kernel_accel = kernel_accel;
3072
3073 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3074
3075 device_param->kernel_power = kernel_power;
3076
3077 if (data.quiet == 0) log_info ("Device #%u: autotuned kernel-accel to %u", device_param->device_id + 1, kernel_accel);
3078 if (data.quiet == 0) log_info ("Device #%u: autotuned kernel-loops to %u", device_param->device_id + 1, kernel_loops);
3079 if (data.quiet == 0) log_info ("");
3080 }
3081
3082 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3083 {
3084 // init speed timer
3085
3086 uint speed_pos = device_param->speed_pos;
3087
3088 #ifdef _POSIX
3089 if (device_param->timer_speed.tv_sec == 0)
3090 {
3091 hc_timer_set (&device_param->timer_speed);
3092 }
3093 #endif
3094
3095 #ifdef _WIN
3096 if (device_param->timer_speed.QuadPart == 0)
3097 {
3098 hc_timer_set (&device_param->timer_speed);
3099 }
3100 #endif
3101
3102 // find higest password length, this is for optimization stuff
3103
3104 uint highest_pw_len = 0;
3105
3106 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3107 {
3108 }
3109 else if (data.attack_kern == ATTACK_KERN_COMBI)
3110 {
3111 }
3112 else if (data.attack_kern == ATTACK_KERN_BF)
3113 {
3114 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3115 + device_param->kernel_params_mp_l_buf32[5];
3116 }
3117
3118 // bitslice optimization stuff
3119
3120 if (data.attack_mode == ATTACK_MODE_BF)
3121 {
3122 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
3123 {
3124 run_kernel_tb (device_param, pws_cnt);
3125 }
3126 }
3127
3128 // iteration type
3129
3130 uint innerloop_step = 0;
3131 uint innerloop_cnt = 0;
3132
3133 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3134 else innerloop_step = 1;
3135
3136 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3137 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3138 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3139
3140 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3141
3142 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3143 {
3144 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3145
3146 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3147
3148 if (data.devices_status == STATUS_CRACKED) break;
3149 if (data.devices_status == STATUS_ABORTED) break;
3150 if (data.devices_status == STATUS_QUIT) break;
3151 if (data.devices_status == STATUS_BYPASS) break;
3152
3153 if (data.salts_shown[salt_pos] == 1) continue;
3154
3155 salt_t *salt_buf = &data.salts_buf[salt_pos];
3156
3157 device_param->kernel_params_buf32[24] = salt_pos;
3158 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3159 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3160
3161 FILE *combs_fp = device_param->combs_fp;
3162
3163 if (data.attack_mode == ATTACK_MODE_COMBI)
3164 {
3165 rewind (combs_fp);
3166 }
3167
3168 // innerloops
3169
3170 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3171 {
3172 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3173
3174 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3175
3176 if (data.devices_status == STATUS_CRACKED) break;
3177 if (data.devices_status == STATUS_ABORTED) break;
3178 if (data.devices_status == STATUS_QUIT) break;
3179 if (data.devices_status == STATUS_BYPASS) break;
3180
3181 uint innerloop_left = innerloop_cnt - innerloop_pos;
3182
3183 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3184
3185 device_param->innerloop_pos = innerloop_pos;
3186 device_param->innerloop_left = innerloop_left;
3187
3188 device_param->kernel_params_buf32[27] = innerloop_left;
3189
3190 // i think we can get rid of this
3191 if (innerloop_left == 0)
3192 {
3193 puts ("bug, how should this happen????\n");
3194
3195 continue;
3196 }
3197
3198 // initialize amplifiers
3199
3200 if (data.attack_mode == ATTACK_MODE_COMBI)
3201 {
3202 char line_buf[BUFSIZ] = { 0 };
3203
3204 uint i = 0;
3205
3206 while (i < innerloop_left)
3207 {
3208 if (feof (combs_fp)) break;
3209
3210 int line_len = fgetl (combs_fp, line_buf);
3211
3212 if (line_len >= PW_MAX1) continue;
3213
3214 line_len = convert_from_hex (line_buf, line_len);
3215
3216 char *line_buf_new = line_buf;
3217
3218 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3219 {
3220 char rule_buf_out[BLOCK_SIZE] = { 0 };
3221
3222 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3223
3224 if (rule_len_out < 0)
3225 {
3226 data.words_progress_rejected[salt_pos] += pws_cnt;
3227
3228 continue;
3229 }
3230
3231 line_len = rule_len_out;
3232
3233 line_buf_new = rule_buf_out;
3234 }
3235
3236 line_len = MIN (line_len, PW_DICTMAX);
3237
3238 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3239
3240 memcpy (ptr, line_buf_new, line_len);
3241
3242 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3243
3244 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3245 {
3246 uppercase (ptr, line_len);
3247 }
3248
3249 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3250 {
3251 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3252 {
3253 ptr[line_len] = 0x80;
3254 }
3255
3256 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3257 {
3258 ptr[line_len] = 0x01;
3259 }
3260 }
3261
3262 device_param->combs_buf[i].pw_len = line_len;
3263
3264 i++;
3265 }
3266
3267 for (uint j = i; j < innerloop_left; j++)
3268 {
3269 device_param->combs_buf[j].i[0] = 0;
3270 device_param->combs_buf[j].i[1] = 0;
3271 device_param->combs_buf[j].i[2] = 0;
3272 device_param->combs_buf[j].i[3] = 0;
3273 device_param->combs_buf[j].i[4] = 0;
3274 device_param->combs_buf[j].i[5] = 0;
3275 device_param->combs_buf[j].i[6] = 0;
3276 device_param->combs_buf[j].i[7] = 0;
3277
3278 device_param->combs_buf[j].pw_len = 0;
3279 }
3280
3281 innerloop_left = i;
3282 }
3283 else if (data.attack_mode == ATTACK_MODE_BF)
3284 {
3285 u64 off = innerloop_pos;
3286
3287 device_param->kernel_params_mp_r_buf64[3] = off;
3288
3289 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3290 }
3291 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3292 {
3293 u64 off = innerloop_pos;
3294
3295 device_param->kernel_params_mp_buf64[3] = off;
3296
3297 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3298 }
3299 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3300 {
3301 u64 off = innerloop_pos;
3302
3303 device_param->kernel_params_mp_buf64[3] = off;
3304
3305 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3306 }
3307
3308 // copy amplifiers
3309
3310 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3311 {
3312 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);
3313 }
3314 else if (data.attack_mode == ATTACK_MODE_COMBI)
3315 {
3316 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);
3317 }
3318 else if (data.attack_mode == ATTACK_MODE_BF)
3319 {
3320 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);
3321 }
3322 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3323 {
3324 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);
3325 }
3326 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3327 {
3328 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);
3329 }
3330
3331 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3332
3333 if (data.benchmark == 1)
3334 {
3335 for (u32 i = 0; i < data.benchmark_repeats; i++)
3336 {
3337 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3338 }
3339 }
3340
3341 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3342
3343 if (data.devices_status == STATUS_CRACKED) break;
3344 if (data.devices_status == STATUS_ABORTED) break;
3345 if (data.devices_status == STATUS_QUIT) break;
3346
3347 /**
3348 * result
3349 */
3350
3351 hc_thread_mutex_lock (mux_display);
3352
3353 check_cracked (device_param, salt_pos);
3354
3355 hc_thread_mutex_unlock (mux_display);
3356
3357 /**
3358 * progress
3359 */
3360
3361 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3362
3363 if (data.benchmark == 1)
3364 {
3365 perf_sum_all = (perf_sum_all * data.benchmark_repeats) + perf_sum_all;
3366 }
3367
3368 hc_thread_mutex_lock (mux_counter);
3369
3370 data.words_progress_done[salt_pos] += perf_sum_all;
3371
3372 hc_thread_mutex_unlock (mux_counter);
3373
3374 /**
3375 * speed
3376 */
3377
3378 float speed_ms;
3379
3380 hc_timer_get (device_param->timer_speed, speed_ms);
3381
3382 hc_timer_set (&device_param->timer_speed);
3383
3384 hc_thread_mutex_lock (mux_display);
3385
3386 device_param->speed_cnt[speed_pos] = perf_sum_all;
3387
3388 device_param->speed_ms[speed_pos] = speed_ms;
3389
3390 device_param->speed_rec[speed_pos] = device_param->timer_speed;
3391
3392 hc_thread_mutex_unlock (mux_display);
3393
3394 speed_pos++;
3395
3396 if (speed_pos == SPEED_CACHE)
3397 {
3398 speed_pos = 0;
3399 }
3400
3401 /**
3402 * benchmark
3403 */
3404
3405 if (data.benchmark == 1) break;
3406 }
3407 }
3408
3409 device_param->speed_pos = speed_pos;
3410 }
3411
3412 static void load_segment (wl_data_t *wl_data, FILE *fd)
3413 {
3414 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3415
3416 wl_data->pos = 0;
3417
3418 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3419
3420 wl_data->buf[wl_data->cnt] = 0;
3421
3422 if (wl_data->cnt == 0) return;
3423
3424 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3425
3426 while (!feof (fd))
3427 {
3428 if (wl_data->cnt == wl_data->avail)
3429 {
3430 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3431
3432 wl_data->avail += wl_data->incr;
3433 }
3434
3435 const int c = fgetc (fd);
3436
3437 if (c == EOF) break;
3438
3439 wl_data->buf[wl_data->cnt] = (char) c;
3440
3441 wl_data->cnt++;
3442
3443 if (c == '\n') break;
3444 }
3445
3446 // ensure stream ends with a newline
3447
3448 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3449 {
3450 wl_data->cnt++;
3451
3452 wl_data->buf[wl_data->cnt - 1] = '\n';
3453 }
3454
3455 return;
3456 }
3457
3458 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3459 {
3460 char *ptr = buf;
3461
3462 for (u32 i = 0; i < sz; i++, ptr++)
3463 {
3464 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3465
3466 if (i == 7)
3467 {
3468 *off = i;
3469 *len = i;
3470
3471 return;
3472 }
3473
3474 if (*ptr != '\n') continue;
3475
3476 *off = i + 1;
3477
3478 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3479
3480 *len = i;
3481
3482 return;
3483 }
3484
3485 *off = sz;
3486 *len = sz;
3487 }
3488
3489 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3490 {
3491 char *ptr = buf;
3492
3493 for (u32 i = 0; i < sz; i++, ptr++)
3494 {
3495 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3496
3497 if (*ptr != '\n') continue;
3498
3499 *off = i + 1;
3500
3501 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3502
3503 *len = i;
3504
3505 return;
3506 }
3507
3508 *off = sz;
3509 *len = sz;
3510 }
3511
3512 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3513 {
3514 char *ptr = buf;
3515
3516 for (u32 i = 0; i < sz; i++, ptr++)
3517 {
3518 if (*ptr != '\n') continue;
3519
3520 *off = i + 1;
3521
3522 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3523
3524 *len = i;
3525
3526 return;
3527 }
3528
3529 *off = sz;
3530 *len = sz;
3531 }
3532
3533 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3534 {
3535 while (wl_data->pos < wl_data->cnt)
3536 {
3537 uint off;
3538 uint len;
3539
3540 char *ptr = wl_data->buf + wl_data->pos;
3541
3542 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3543
3544 wl_data->pos += off;
3545
3546 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3547 {
3548 char rule_buf_out[BLOCK_SIZE] = { 0 };
3549
3550 int rule_len_out = -1;
3551
3552 if (len < BLOCK_SIZE)
3553 {
3554 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3555 }
3556
3557 if (rule_len_out < 0)
3558 {
3559 continue;
3560 }
3561
3562 if (rule_len_out > PW_MAX)
3563 {
3564 continue;
3565 }
3566 }
3567 else
3568 {
3569 if (len > PW_MAX)
3570 {
3571 continue;
3572 }
3573 }
3574
3575 *out_buf = ptr;
3576 *out_len = len;
3577
3578 return;
3579 }
3580
3581 if (feof (fd))
3582 {
3583 fprintf (stderr, "BUG feof()!!\n");
3584
3585 return;
3586 }
3587
3588 load_segment (wl_data, fd);
3589
3590 get_next_word (wl_data, fd, out_buf, out_len);
3591 }
3592
3593 #ifdef _POSIX
3594 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3595 #endif
3596
3597 #ifdef _WIN
3598 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3599 #endif
3600 {
3601 hc_signal (NULL);
3602
3603 dictstat_t d;
3604
3605 d.cnt = 0;
3606
3607 #ifdef _POSIX
3608 fstat (fileno (fd), &d.stat);
3609 #endif
3610
3611 #ifdef _WIN
3612 _fstat64 (fileno (fd), &d.stat);
3613 #endif
3614
3615 d.stat.st_mode = 0;
3616 d.stat.st_nlink = 0;
3617 d.stat.st_uid = 0;
3618 d.stat.st_gid = 0;
3619 d.stat.st_rdev = 0;
3620 d.stat.st_atime = 0;
3621
3622 #ifdef _POSIX
3623 d.stat.st_blksize = 0;
3624 d.stat.st_blocks = 0;
3625 #endif
3626
3627 if (d.stat.st_size == 0) return 0;
3628
3629 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3630
3631 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3632 {
3633 if (d_cache)
3634 {
3635 u64 cnt = d_cache->cnt;
3636
3637 u64 keyspace = cnt;
3638
3639 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3640 {
3641 keyspace *= data.kernel_rules_cnt;
3642 }
3643 else if (data.attack_kern == ATTACK_KERN_COMBI)
3644 {
3645 keyspace *= data.combs_cnt;
3646 }
3647
3648 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);
3649 if (data.quiet == 0) log_info ("");
3650
3651 hc_signal (sigHandler_default);
3652
3653 return (keyspace);
3654 }
3655 }
3656
3657 time_t now = 0;
3658 time_t prev = 0;
3659
3660 u64 comp = 0;
3661 u64 cnt = 0;
3662 u64 cnt2 = 0;
3663
3664 while (!feof (fd))
3665 {
3666 load_segment (wl_data, fd);
3667
3668 comp += wl_data->cnt;
3669
3670 u32 i = 0;
3671
3672 while (i < wl_data->cnt)
3673 {
3674 u32 len;
3675 u32 off;
3676
3677 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3678
3679 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3680 {
3681 char rule_buf_out[BLOCK_SIZE] = { 0 };
3682
3683 int rule_len_out = -1;
3684
3685 if (len < BLOCK_SIZE)
3686 {
3687 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3688 }
3689
3690 if (rule_len_out < 0)
3691 {
3692 len = PW_MAX1;
3693 }
3694 else
3695 {
3696 len = rule_len_out;
3697 }
3698 }
3699
3700 if (len < PW_MAX1)
3701 {
3702 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3703 {
3704 cnt += data.kernel_rules_cnt;
3705 }
3706 else if (data.attack_kern == ATTACK_KERN_COMBI)
3707 {
3708 cnt += data.combs_cnt;
3709 }
3710
3711 d.cnt++;
3712 }
3713
3714 i += off;
3715
3716 cnt2++;
3717 }
3718
3719 time (&now);
3720
3721 if ((now - prev) == 0) continue;
3722
3723 float percent = (float) comp / (float) d.stat.st_size;
3724
3725 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);
3726
3727 time (&prev);
3728 }
3729
3730 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);
3731 if (data.quiet == 0) log_info ("");
3732
3733 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3734
3735 hc_signal (sigHandler_default);
3736
3737 return (cnt);
3738 }
3739
3740 static void *thread_monitor (void *p)
3741 {
3742 uint runtime_check = 0;
3743 uint remove_check = 0;
3744 uint status_check = 0;
3745 uint restore_check = 0;
3746
3747 uint restore_left = data.restore_timer;
3748 uint remove_left = data.remove_timer;
3749 uint status_left = data.status_timer;
3750
3751 #ifdef HAVE_HWMON
3752 uint hwmon_check = 0;
3753
3754 // these variables are mainly used for fan control (AMD only)
3755
3756 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3757
3758 // temperature controller "loopback" values
3759
3760 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3761 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3762
3763 #ifdef HAVE_ADL
3764 int temp_threshold = 1; // degrees celcius
3765
3766 int fan_speed_min = 15; // in percentage
3767 int fan_speed_max = 100;
3768 #endif // HAVE_ADL
3769
3770 time_t last_temp_check_time;
3771 #endif // HAVE_HWMON
3772
3773 uint sleep_time = 1;
3774
3775 if (data.runtime)
3776 {
3777 runtime_check = 1;
3778 }
3779
3780 if (data.restore_timer)
3781 {
3782 restore_check = 1;
3783 }
3784
3785 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3786 {
3787 remove_check = 1;
3788 }
3789
3790 if (data.status == 1)
3791 {
3792 status_check = 1;
3793 }
3794
3795 #ifdef HAVE_HWMON
3796 if (data.gpu_temp_disable == 0)
3797 {
3798 time (&last_temp_check_time);
3799
3800 hwmon_check = 1;
3801 }
3802 #endif
3803
3804 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3805 {
3806 #ifdef HAVE_HWMON
3807 if (hwmon_check == 0)
3808 #endif
3809 return (p);
3810 }
3811
3812 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3813 {
3814 hc_sleep (sleep_time);
3815
3816 if (data.devices_status != STATUS_RUNNING) continue;
3817
3818 #ifdef HAVE_HWMON
3819 if (hwmon_check == 1)
3820 {
3821 hc_thread_mutex_lock (mux_adl);
3822
3823 time_t temp_check_time;
3824
3825 time (&temp_check_time);
3826
3827 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3828
3829 if (Ta == 0) Ta = 1;
3830
3831 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3832 {
3833 hc_device_param_t *device_param = &data.devices_param[device_id];
3834
3835 if (device_param->skipped) continue;
3836
3837 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3838
3839 const int temperature = hm_get_temperature_with_device_id (device_id);
3840
3841 if (temperature > (int) data.gpu_temp_abort)
3842 {
3843 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3844
3845 if (data.devices_status != STATUS_QUIT) myabort ();
3846
3847 break;
3848 }
3849
3850 #ifdef HAVE_ADL
3851 const int gpu_temp_retain = data.gpu_temp_retain;
3852
3853 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3854 {
3855 if (data.hm_device[device_id].fan_supported == 1)
3856 {
3857 int temp_cur = temperature;
3858
3859 int temp_diff_new = gpu_temp_retain - temp_cur;
3860
3861 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3862
3863 // calculate Ta value (time difference in seconds between the last check and this check)
3864
3865 last_temp_check_time = temp_check_time;
3866
3867 float Kp = 1.8;
3868 float Ki = 0.005;
3869 float Kd = 6;
3870
3871 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3872
3873 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);
3874
3875 if (abs (fan_diff_required) >= temp_threshold)
3876 {
3877 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3878
3879 int fan_speed_level = fan_speed_cur;
3880
3881 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3882
3883 int fan_speed_new = fan_speed_level - fan_diff_required;
3884
3885 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3886 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3887
3888 if (fan_speed_new != fan_speed_cur)
3889 {
3890 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3891 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3892
3893 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3894 {
3895 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3896
3897 fan_speed_chgd[device_id] = 1;
3898 }
3899
3900 temp_diff_old[device_id] = temp_diff_new;
3901 }
3902 }
3903 }
3904 }
3905 #endif // HAVE_ADL
3906 }
3907
3908 hc_thread_mutex_unlock (mux_adl);
3909 }
3910 #endif // HAVE_HWMON
3911
3912 if (restore_check == 1)
3913 {
3914 restore_left--;
3915
3916 if (restore_left == 0)
3917 {
3918 if (data.restore_disable == 0) cycle_restore ();
3919
3920 restore_left = data.restore_timer;
3921 }
3922 }
3923
3924 if ((runtime_check == 1) && (data.runtime_start > 0))
3925 {
3926 time_t runtime_cur;
3927
3928 time (&runtime_cur);
3929
3930 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3931
3932 if (runtime_left <= 0)
3933 {
3934 if (data.benchmark == 0)
3935 {
3936 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3937 }
3938
3939 if (data.devices_status != STATUS_QUIT) myabort ();
3940 }
3941 }
3942
3943 if (remove_check == 1)
3944 {
3945 remove_left--;
3946
3947 if (remove_left == 0)
3948 {
3949 if (data.digests_saved != data.digests_done)
3950 {
3951 data.digests_saved = data.digests_done;
3952
3953 save_hash ();
3954 }
3955
3956 remove_left = data.remove_timer;
3957 }
3958 }
3959
3960 if (status_check == 1)
3961 {
3962 status_left--;
3963
3964 if (status_left == 0)
3965 {
3966 hc_thread_mutex_lock (mux_display);
3967
3968 if (data.quiet == 0) clear_prompt ();
3969
3970 if (data.quiet == 0) log_info ("");
3971
3972 status_display ();
3973
3974 if (data.quiet == 0) log_info ("");
3975
3976 hc_thread_mutex_unlock (mux_display);
3977
3978 status_left = data.status_timer;
3979 }
3980 }
3981 }
3982
3983 #ifdef HAVE_HWMON
3984 myfree (fan_speed_chgd);
3985
3986 myfree (temp_diff_old);
3987 myfree (temp_diff_sum);
3988 #endif
3989
3990 p = NULL;
3991
3992 return (p);
3993 }
3994
3995 static void *thread_outfile_remove (void *p)
3996 {
3997 // some hash-dependent constants
3998 char *outfile_dir = data.outfile_check_directory;
3999 uint dgst_size = data.dgst_size;
4000 uint isSalted = data.isSalted;
4001 uint esalt_size = data.esalt_size;
4002 uint hash_mode = data.hash_mode;
4003
4004 uint outfile_check_timer = data.outfile_check_timer;
4005
4006 char separator = data.separator;
4007
4008 // some hash-dependent functions
4009 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4010 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4011
4012 // buffers
4013 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4014
4015 hash_buf.digest = mymalloc (dgst_size);
4016
4017 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4018
4019 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4020
4021 uint digest_buf[64] = { 0 };
4022
4023 outfile_data_t *out_info = NULL;
4024
4025 char **out_files = NULL;
4026
4027 time_t folder_mtime = 0;
4028
4029 int out_cnt = 0;
4030
4031 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4032
4033 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4034 {
4035 hc_sleep (1);
4036
4037 if (data.devices_status != STATUS_RUNNING) continue;
4038
4039 check_left--;
4040
4041 if (check_left == 0)
4042 {
4043 struct stat outfile_check_stat;
4044
4045 if (stat (outfile_dir, &outfile_check_stat) == 0)
4046 {
4047 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4048
4049 if (is_dir == 1)
4050 {
4051 if (outfile_check_stat.st_mtime > folder_mtime)
4052 {
4053 char **out_files_new = scan_directory (outfile_dir);
4054
4055 int out_cnt_new = count_dictionaries (out_files_new);
4056
4057 outfile_data_t *out_info_new = NULL;
4058
4059 if (out_cnt_new > 0)
4060 {
4061 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4062
4063 for (int i = 0; i < out_cnt_new; i++)
4064 {
4065 out_info_new[i].file_name = out_files_new[i];
4066
4067 // check if there are files that we have seen/checked before (and not changed)
4068
4069 for (int j = 0; j < out_cnt; j++)
4070 {
4071 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4072 {
4073 struct stat outfile_stat;
4074
4075 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4076 {
4077 if (outfile_stat.st_ctime == out_info[j].ctime)
4078 {
4079 out_info_new[i].ctime = out_info[j].ctime;
4080 out_info_new[i].seek = out_info[j].seek;
4081 }
4082 }
4083 }
4084 }
4085 }
4086 }
4087
4088 local_free (out_info);
4089 local_free (out_files);
4090
4091 out_files = out_files_new;
4092 out_cnt = out_cnt_new;
4093 out_info = out_info_new;
4094
4095 folder_mtime = outfile_check_stat.st_mtime;
4096 }
4097
4098 for (int j = 0; j < out_cnt; j++)
4099 {
4100 FILE *fp = fopen (out_info[j].file_name, "rb");
4101
4102 if (fp != NULL)
4103 {
4104 //hc_thread_mutex_lock (mux_display);
4105
4106 #ifdef _POSIX
4107 struct stat outfile_stat;
4108
4109 fstat (fileno (fp), &outfile_stat);
4110 #endif
4111
4112 #ifdef _WIN
4113 struct stat64 outfile_stat;
4114
4115 _fstat64 (fileno (fp), &outfile_stat);
4116 #endif
4117
4118 if (outfile_stat.st_ctime > out_info[j].ctime)
4119 {
4120 out_info[j].ctime = outfile_stat.st_ctime;
4121 out_info[j].seek = 0;
4122 }
4123
4124 fseek (fp, out_info[j].seek, SEEK_SET);
4125
4126 while (!feof (fp))
4127 {
4128 char line_buf[BUFSIZ] = { 0 };
4129
4130 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
4131
4132 if (ptr == NULL) break;
4133
4134 int line_len = strlen (line_buf);
4135
4136 if (line_len <= 0) continue;
4137
4138 int iter = MAX_CUT_TRIES;
4139
4140 for (uint i = line_len - 1; i && iter; i--, line_len--)
4141 {
4142 if (line_buf[i] != separator) continue;
4143
4144 int parser_status = PARSER_OK;
4145
4146 if ((hash_mode != 2500) && (hash_mode != 6800))
4147 {
4148 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4149 }
4150
4151 uint found = 0;
4152
4153 if (parser_status == PARSER_OK)
4154 {
4155 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4156 {
4157 if (data.salts_shown[salt_pos] == 1) continue;
4158
4159 salt_t *salt_buf = &data.salts_buf[salt_pos];
4160
4161 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4162 {
4163 uint idx = salt_buf->digests_offset + digest_pos;
4164
4165 if (data.digests_shown[idx] == 1) continue;
4166
4167 uint cracked = 0;
4168
4169 if (hash_mode == 6800)
4170 {
4171 if (i == salt_buf->salt_len)
4172 {
4173 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4174 }
4175 }
4176 else if (hash_mode == 2500)
4177 {
4178 // BSSID : MAC1 : MAC2 (:plain)
4179 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4180 {
4181 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4182
4183 if (!cracked) continue;
4184
4185 // now compare MAC1 and MAC2 too, since we have this additional info
4186 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4187 char *mac2_pos = mac1_pos + 12 + 1;
4188
4189 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4190 wpa_t *wpa = &wpas[salt_pos];
4191
4192 uint pke[25] = { 0 };
4193
4194 char *pke_ptr = (char *) pke;
4195
4196 for (uint i = 0; i < 25; i++)
4197 {
4198 pke[i] = byte_swap_32 (wpa->pke[i]);
4199 }
4200
4201 u8 mac1[6] = { 0 };
4202 u8 mac2[6] = { 0 };
4203
4204 memcpy (mac1, pke_ptr + 23, 6);
4205 memcpy (mac2, pke_ptr + 29, 6);
4206
4207 // compare hex string(s) vs binary MAC address(es)
4208
4209 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4210 {
4211 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4212 {
4213 cracked = 0;
4214 break;
4215 }
4216 }
4217
4218 // early skip ;)
4219 if (!cracked) continue;
4220
4221 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4222 {
4223 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4224 {
4225 cracked = 0;
4226 break;
4227 }
4228 }
4229 }
4230 }
4231 else
4232 {
4233 char *digests_buf_ptr = (char *) data.digests_buf;
4234
4235 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4236
4237 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4238 }
4239
4240 if (cracked == 1)
4241 {
4242 found = 1;
4243
4244 data.digests_shown[idx] = 1;
4245
4246 data.digests_done++;
4247
4248 salt_buf->digests_done++;
4249
4250 if (salt_buf->digests_done == salt_buf->digests_cnt)
4251 {
4252 data.salts_shown[salt_pos] = 1;
4253
4254 data.salts_done++;
4255
4256 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4257 }
4258 }
4259 }
4260
4261 if (data.devices_status == STATUS_CRACKED) break;
4262 }
4263 }
4264
4265 if (found) break;
4266
4267 if (data.devices_status == STATUS_CRACKED) break;
4268
4269 iter--;
4270 }
4271
4272 if (data.devices_status == STATUS_CRACKED) break;
4273 }
4274
4275 out_info[j].seek = ftell (fp);
4276
4277 //hc_thread_mutex_unlock (mux_display);
4278
4279 fclose (fp);
4280 }
4281 }
4282 }
4283 }
4284
4285 check_left = outfile_check_timer;
4286 }
4287 }
4288
4289 if (esalt_size) local_free (hash_buf.esalt);
4290
4291 if (isSalted) local_free (hash_buf.salt);
4292
4293 local_free (hash_buf.digest);
4294
4295 local_free (out_info);
4296
4297 local_free (out_files);
4298
4299 p = NULL;
4300
4301 return (p);
4302 }
4303
4304 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4305 {
4306 if (device_param->pws_cnt < device_param->kernel_power)
4307 {
4308 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4309
4310 memcpy (pw->i, pw_buf, pw_len);
4311
4312 pw->pw_len = pw_len;
4313
4314 device_param->pws_cnt++;
4315 }
4316 else
4317 {
4318 fprintf (stderr, "BUG pw_add()!!\n");
4319
4320 return;
4321 }
4322 }
4323
4324 static uint get_work (hc_device_param_t *device_param, const u64 max, const bool allow_div)
4325 {
4326 hc_thread_mutex_lock (mux_dispatcher);
4327
4328 const u64 words_cur = data.words_cur;
4329 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4330
4331 device_param->words_off = words_cur;
4332
4333 const u64 words_left = words_base - words_cur;
4334
4335 if (allow_div)
4336 {
4337 if (data.kernel_power_all > words_left)
4338 {
4339 if (data.kernel_power_div == 0)
4340 {
4341 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4342 }
4343 }
4344
4345 if (data.kernel_power_div)
4346 {
4347 if (device_param->kernel_power == device_param->kernel_power_user)
4348 {
4349 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4350
4351 if (kernel_power_new < device_param->kernel_power)
4352 {
4353 device_param->kernel_power = kernel_power_new;
4354 }
4355 }
4356 }
4357 }
4358
4359 const uint kernel_power = device_param->kernel_power;
4360
4361 uint work = MIN (words_left, kernel_power);
4362
4363 work = MIN (work, max);
4364
4365 data.words_cur += work;
4366
4367 hc_thread_mutex_unlock (mux_dispatcher);
4368
4369 return work;
4370 }
4371
4372 static void *thread_calc_stdin (void *p)
4373 {
4374 hc_device_param_t *device_param = (hc_device_param_t *) p;
4375
4376 if (device_param->skipped) return NULL;
4377
4378 autotune (device_param);
4379
4380 const uint attack_kern = data.attack_kern;
4381
4382 const uint kernel_power = device_param->kernel_power;
4383
4384 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4385 {
4386 hc_thread_mutex_lock (mux_dispatcher);
4387
4388 if (feof (stdin) != 0)
4389 {
4390 hc_thread_mutex_unlock (mux_dispatcher);
4391
4392 break;
4393 }
4394
4395 uint words_cur = 0;
4396
4397 while (words_cur < kernel_power)
4398 {
4399 char buf[BUFSIZ] = { 0 };
4400
4401 char *line_buf = fgets (buf, sizeof (buf), stdin);
4402
4403 if (line_buf == NULL) break;
4404
4405 uint line_len = in_superchop (line_buf);
4406
4407 line_len = convert_from_hex (line_buf, line_len);
4408
4409 // post-process rule engine
4410
4411 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4412 {
4413 char rule_buf_out[BLOCK_SIZE] = { 0 };
4414
4415 int rule_len_out = -1;
4416
4417 if (line_len < BLOCK_SIZE)
4418 {
4419 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4420 }
4421
4422 if (rule_len_out < 0) continue;
4423
4424 line_buf = rule_buf_out;
4425 line_len = rule_len_out;
4426 }
4427
4428 if (line_len > PW_MAX)
4429 {
4430 continue;
4431 }
4432
4433 if (attack_kern == ATTACK_KERN_STRAIGHT)
4434 {
4435 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4436 {
4437 hc_thread_mutex_lock (mux_counter);
4438
4439 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4440 {
4441 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4442 }
4443
4444 hc_thread_mutex_unlock (mux_counter);
4445
4446 continue;
4447 }
4448 }
4449 else if (attack_kern == ATTACK_KERN_COMBI)
4450 {
4451 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4452 // since we still need to combine the plains
4453
4454 if (line_len > data.pw_max)
4455 {
4456 hc_thread_mutex_lock (mux_counter);
4457
4458 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4459 {
4460 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4461 }
4462
4463 hc_thread_mutex_unlock (mux_counter);
4464
4465 continue;
4466 }
4467 }
4468
4469 pw_add (device_param, (u8 *) line_buf, line_len);
4470
4471 words_cur++;
4472
4473 if (data.devices_status == STATUS_CRACKED) break;
4474 if (data.devices_status == STATUS_ABORTED) break;
4475 if (data.devices_status == STATUS_QUIT) break;
4476 if (data.devices_status == STATUS_BYPASS) break;
4477 }
4478
4479 hc_thread_mutex_unlock (mux_dispatcher);
4480
4481 if (data.devices_status == STATUS_CRACKED) break;
4482 if (data.devices_status == STATUS_ABORTED) break;
4483 if (data.devices_status == STATUS_QUIT) break;
4484 if (data.devices_status == STATUS_BYPASS) break;
4485
4486 // flush
4487
4488 const uint pws_cnt = device_param->pws_cnt;
4489
4490 if (pws_cnt)
4491 {
4492 run_copy (device_param, pws_cnt);
4493
4494 run_cracker (device_param, pws_cnt);
4495
4496 device_param->pws_cnt = 0;
4497 }
4498 }
4499
4500 device_param->kernel_accel = 0;
4501 device_param->kernel_loops = 0;
4502
4503 return NULL;
4504 }
4505
4506 static void *thread_calc (void *p)
4507 {
4508 hc_device_param_t *device_param = (hc_device_param_t *) p;
4509
4510 if (device_param->skipped) return NULL;
4511
4512 autotune (device_param);
4513
4514 const uint attack_mode = data.attack_mode;
4515 const uint attack_kern = data.attack_kern;
4516
4517 if (attack_mode == ATTACK_MODE_BF)
4518 {
4519 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4520 {
4521 const uint work = get_work (device_param, -1, true);
4522
4523 if (work == 0) break;
4524
4525 const u64 words_off = device_param->words_off;
4526 const u64 words_fin = words_off + work;
4527
4528 const uint pws_cnt = work;
4529
4530 device_param->pws_cnt = pws_cnt;
4531
4532 if (pws_cnt)
4533 {
4534 run_copy (device_param, pws_cnt);
4535
4536 run_cracker (device_param, pws_cnt);
4537
4538 device_param->pws_cnt = 0;
4539 }
4540
4541 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4542
4543 if (data.devices_status == STATUS_CRACKED) break;
4544 if (data.devices_status == STATUS_ABORTED) break;
4545 if (data.devices_status == STATUS_QUIT) break;
4546 if (data.devices_status == STATUS_BYPASS) break;
4547
4548 if (data.benchmark == 1) break;
4549
4550 device_param->words_done = words_fin;
4551 }
4552 }
4553 else
4554 {
4555 const uint segment_size = data.segment_size;
4556
4557 char *dictfile = data.dictfile;
4558
4559 if (attack_mode == ATTACK_MODE_COMBI)
4560 {
4561 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4562 {
4563 dictfile = data.dictfile2;
4564 }
4565 }
4566
4567 FILE *fd = fopen (dictfile, "rb");
4568
4569 if (fd == NULL)
4570 {
4571 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4572
4573 return NULL;
4574 }
4575
4576 if (attack_mode == ATTACK_MODE_COMBI)
4577 {
4578 const uint combs_mode = data.combs_mode;
4579
4580 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4581 {
4582 const char *dictfilec = data.dictfile2;
4583
4584 FILE *combs_fp = fopen (dictfilec, "rb");
4585
4586 if (combs_fp == NULL)
4587 {
4588 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4589
4590 fclose (fd);
4591
4592 return NULL;
4593 }
4594
4595 device_param->combs_fp = combs_fp;
4596 }
4597 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4598 {
4599 const char *dictfilec = data.dictfile;
4600
4601 FILE *combs_fp = fopen (dictfilec, "rb");
4602
4603 if (combs_fp == NULL)
4604 {
4605 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4606
4607 fclose (fd);
4608
4609 return NULL;
4610 }
4611
4612 device_param->combs_fp = combs_fp;
4613 }
4614 }
4615
4616 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4617
4618 wl_data->buf = (char *) mymalloc (segment_size);
4619 wl_data->avail = segment_size;
4620 wl_data->incr = segment_size;
4621 wl_data->cnt = 0;
4622 wl_data->pos = 0;
4623
4624 u64 words_cur = 0;
4625
4626 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4627 {
4628 u64 words_off = 0;
4629 u64 words_fin = 0;
4630
4631 bool allow_div = true;
4632
4633 u64 max = -1;
4634
4635 while (max)
4636 {
4637 const uint work = get_work (device_param, max, allow_div);
4638
4639 allow_div = false;
4640
4641 if (work == 0) break;
4642
4643 words_off = device_param->words_off;
4644 words_fin = words_off + work;
4645
4646 char *line_buf;
4647 uint line_len;
4648
4649 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4650
4651 max = 0;
4652
4653 for ( ; words_cur < words_fin; words_cur++)
4654 {
4655 get_next_word (wl_data, fd, &line_buf, &line_len);
4656
4657 line_len = convert_from_hex (line_buf, line_len);
4658
4659 // post-process rule engine
4660
4661 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4662 {
4663 char rule_buf_out[BLOCK_SIZE] = { 0 };
4664
4665 int rule_len_out = -1;
4666
4667 if (line_len < BLOCK_SIZE)
4668 {
4669 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4670 }
4671
4672 if (rule_len_out < 0) continue;
4673
4674 line_buf = rule_buf_out;
4675 line_len = rule_len_out;
4676 }
4677
4678 if (attack_kern == ATTACK_KERN_STRAIGHT)
4679 {
4680 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4681 {
4682 max++;
4683
4684 hc_thread_mutex_lock (mux_counter);
4685
4686 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4687 {
4688 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4689 }
4690
4691 hc_thread_mutex_unlock (mux_counter);
4692
4693 continue;
4694 }
4695 }
4696 else if (attack_kern == ATTACK_KERN_COMBI)
4697 {
4698 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4699 // since we still need to combine the plains
4700
4701 if (line_len > data.pw_max)
4702 {
4703 max++;
4704
4705 hc_thread_mutex_lock (mux_counter);
4706
4707 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4708 {
4709 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4710 }
4711
4712 hc_thread_mutex_unlock (mux_counter);
4713
4714 continue;
4715 }
4716 }
4717
4718 pw_add (device_param, (u8 *) line_buf, line_len);
4719
4720 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4721
4722 if (data.devices_status == STATUS_CRACKED) break;
4723 if (data.devices_status == STATUS_ABORTED) break;
4724 if (data.devices_status == STATUS_QUIT) break;
4725 if (data.devices_status == STATUS_BYPASS) break;
4726 }
4727
4728 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4729
4730 if (data.devices_status == STATUS_CRACKED) break;
4731 if (data.devices_status == STATUS_ABORTED) break;
4732 if (data.devices_status == STATUS_QUIT) break;
4733 if (data.devices_status == STATUS_BYPASS) break;
4734 }
4735
4736 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4737
4738 if (data.devices_status == STATUS_CRACKED) break;
4739 if (data.devices_status == STATUS_ABORTED) break;
4740 if (data.devices_status == STATUS_QUIT) break;
4741 if (data.devices_status == STATUS_BYPASS) break;
4742
4743 //
4744 // flush
4745 //
4746
4747 const uint pws_cnt = device_param->pws_cnt;
4748
4749 if (pws_cnt)
4750 {
4751 run_copy (device_param, pws_cnt);
4752
4753 run_cracker (device_param, pws_cnt);
4754
4755 device_param->pws_cnt = 0;
4756 }
4757
4758 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4759
4760 if (data.devices_status == STATUS_CRACKED) break;
4761 if (data.devices_status == STATUS_ABORTED) break;
4762 if (data.devices_status == STATUS_QUIT) break;
4763 if (data.devices_status == STATUS_BYPASS) break;
4764
4765 if (words_fin == 0) break;
4766
4767 device_param->words_done = words_fin;
4768 }
4769
4770 if (attack_mode == ATTACK_MODE_COMBI)
4771 {
4772 fclose (device_param->combs_fp);
4773 }
4774
4775 free (wl_data->buf);
4776 free (wl_data);
4777
4778 fclose (fd);
4779 }
4780
4781 device_param->kernel_accel = 0;
4782 device_param->kernel_loops = 0;
4783
4784 return NULL;
4785 }
4786
4787 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4788 {
4789 if (!device_param)
4790 {
4791 log_error ("ERROR: %s : Invalid argument", __func__);
4792
4793 exit (-1);
4794 }
4795
4796 salt_t *salt_buf = &data.salts_buf[salt_pos];
4797
4798 device_param->kernel_params_buf32[24] = salt_pos;
4799 device_param->kernel_params_buf32[27] = 1;
4800 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4801 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4802 device_param->kernel_params_buf32[30] = 0;
4803 device_param->kernel_params_buf32[31] = 1;
4804
4805 char *dictfile_old = data.dictfile;
4806
4807 const char *weak_hash_check = "weak-hash-check";
4808
4809 data.dictfile = (char *) weak_hash_check;
4810
4811 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4812
4813 data.kernel_rules_buf[0].cmds[0] = 0;
4814
4815 /**
4816 * run the kernel
4817 */
4818
4819 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4820 {
4821 run_kernel (KERN_RUN_1, device_param, 1, false);
4822 }
4823 else
4824 {
4825 run_kernel (KERN_RUN_1, device_param, 1, false);
4826
4827 uint loop_step = 16;
4828
4829 const uint iter = salt_buf->salt_iter;
4830
4831 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4832 {
4833 uint loop_left = iter - loop_pos;
4834
4835 loop_left = MIN (loop_left, loop_step);
4836
4837 device_param->kernel_params_buf32[25] = loop_pos;
4838 device_param->kernel_params_buf32[26] = loop_left;
4839
4840 run_kernel (KERN_RUN_2, device_param, 1, false);
4841 }
4842
4843 run_kernel (KERN_RUN_3, device_param, 1, false);
4844 }
4845
4846 /**
4847 * result
4848 */
4849
4850 check_cracked (device_param, salt_pos);
4851
4852 /**
4853 * cleanup
4854 */
4855
4856 device_param->kernel_params_buf32[24] = 0;
4857 device_param->kernel_params_buf32[25] = 0;
4858 device_param->kernel_params_buf32[26] = 0;
4859 device_param->kernel_params_buf32[27] = 0;
4860 device_param->kernel_params_buf32[28] = 0;
4861 device_param->kernel_params_buf32[29] = 0;
4862 device_param->kernel_params_buf32[30] = 0;
4863 device_param->kernel_params_buf32[31] = 0;
4864
4865 data.dictfile = dictfile_old;
4866
4867 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4868 }
4869
4870 // hlfmt hashcat
4871
4872 static void hlfmt_hash_hashcat (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4873 {
4874 if (data.username == 0)
4875 {
4876 *hashbuf_pos = line_buf;
4877 *hashbuf_len = line_len;
4878 }
4879 else
4880 {
4881 char *pos = line_buf;
4882 int len = line_len;
4883
4884 for (int i = 0; i < line_len; i++, pos++, len--)
4885 {
4886 if (line_buf[i] == data.separator)
4887 {
4888 pos++;
4889
4890 len--;
4891
4892 break;
4893 }
4894 }
4895
4896 *hashbuf_pos = pos;
4897 *hashbuf_len = len;
4898 }
4899 }
4900
4901 static void hlfmt_user_hashcat (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4902 {
4903 char *pos = NULL;
4904 int len = 0;
4905
4906 int sep_cnt = 0;
4907
4908 for (int i = 0; i < line_len; i++)
4909 {
4910 if (line_buf[i] == data.separator)
4911 {
4912 sep_cnt++;
4913
4914 continue;
4915 }
4916
4917 if (sep_cnt == 0)
4918 {
4919 if (pos == NULL) pos = line_buf + i;
4920
4921 len++;
4922 }
4923 }
4924
4925 *userbuf_pos = pos;
4926 *userbuf_len = len;
4927 }
4928
4929 // hlfmt pwdump
4930
4931 static int hlfmt_detect_pwdump (char line_buf[BUFSIZ], int line_len)
4932 {
4933 int sep_cnt = 0;
4934
4935 int sep2_len = 0;
4936 int sep3_len = 0;
4937
4938 for (int i = 0; i < line_len; i++)
4939 {
4940 if (line_buf[i] == ':')
4941 {
4942 sep_cnt++;
4943
4944 continue;
4945 }
4946
4947 if (sep_cnt == 2) sep2_len++;
4948 if (sep_cnt == 3) sep3_len++;
4949 }
4950
4951 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4952
4953 return 0;
4954 }
4955
4956 static void hlfmt_hash_pwdump (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4957 {
4958 char *pos = NULL;
4959 int len = 0;
4960
4961 int sep_cnt = 0;
4962
4963 for (int i = 0; i < line_len; i++)
4964 {
4965 if (line_buf[i] == ':')
4966 {
4967 sep_cnt++;
4968
4969 continue;
4970 }
4971
4972 if (data.hash_mode == 1000)
4973 {
4974 if (sep_cnt == 3)
4975 {
4976 if (pos == NULL) pos = line_buf + i;
4977
4978 len++;
4979 }
4980 }
4981 else if (data.hash_mode == 3000)
4982 {
4983 if (sep_cnt == 2)
4984 {
4985 if (pos == NULL) pos = line_buf + i;
4986
4987 len++;
4988 }
4989 }
4990 }
4991
4992 *hashbuf_pos = pos;
4993 *hashbuf_len = len;
4994 }
4995
4996 static void hlfmt_user_pwdump (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4997 {
4998 char *pos = NULL;
4999 int len = 0;
5000
5001 int sep_cnt = 0;
5002
5003 for (int i = 0; i < line_len; i++)
5004 {
5005 if (line_buf[i] == ':')
5006 {
5007 sep_cnt++;
5008
5009 continue;
5010 }
5011
5012 if (sep_cnt == 0)
5013 {
5014 if (pos == NULL) pos = line_buf + i;
5015
5016 len++;
5017 }
5018 }
5019
5020 *userbuf_pos = pos;
5021 *userbuf_len = len;
5022 }
5023
5024 // hlfmt passwd
5025
5026 static int hlfmt_detect_passwd (char line_buf[BUFSIZ], int line_len)
5027 {
5028 int sep_cnt = 0;
5029
5030 char sep5_first = 0;
5031 char sep6_first = 0;
5032
5033 for (int i = 0; i < line_len; i++)
5034 {
5035 if (line_buf[i] == ':')
5036 {
5037 sep_cnt++;
5038
5039 continue;
5040 }
5041
5042 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5043 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5044 }
5045
5046 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5047
5048 return 0;
5049 }
5050
5051 static void hlfmt_hash_passwd (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5052 {
5053 char *pos = NULL;
5054 int len = 0;
5055
5056 int sep_cnt = 0;
5057
5058 for (int i = 0; i < line_len; i++)
5059 {
5060 if (line_buf[i] == ':')
5061 {
5062 sep_cnt++;
5063
5064 continue;
5065 }
5066
5067 if (sep_cnt == 1)
5068 {
5069 if (pos == NULL) pos = line_buf + i;
5070
5071 len++;
5072 }
5073 }
5074
5075 *hashbuf_pos = pos;
5076 *hashbuf_len = len;
5077 }
5078
5079 static void hlfmt_user_passwd (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5080 {
5081 char *pos = NULL;
5082 int len = 0;
5083
5084 int sep_cnt = 0;
5085
5086 for (int i = 0; i < line_len; i++)
5087 {
5088 if (line_buf[i] == ':')
5089 {
5090 sep_cnt++;
5091
5092 continue;
5093 }
5094
5095 if (sep_cnt == 0)
5096 {
5097 if (pos == NULL) pos = line_buf + i;
5098
5099 len++;
5100 }
5101 }
5102
5103 *userbuf_pos = pos;
5104 *userbuf_len = len;
5105 }
5106
5107 // hlfmt shadow
5108
5109 static int hlfmt_detect_shadow (char line_buf[BUFSIZ], int line_len)
5110 {
5111 int sep_cnt = 0;
5112
5113 for (int i = 0; i < line_len; i++)
5114 {
5115 if (line_buf[i] == ':') sep_cnt++;
5116 }
5117
5118 if (sep_cnt == 8) return 1;
5119
5120 return 0;
5121 }
5122
5123 static void hlfmt_hash_shadow (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5124 {
5125 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5126 }
5127
5128 static void hlfmt_user_shadow (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5129 {
5130 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5131 }
5132
5133 // hlfmt main
5134
5135 static void hlfmt_hash (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5136 {
5137 switch (hashfile_format)
5138 {
5139 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5140 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5141 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5142 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5143 }
5144 }
5145
5146 static void hlfmt_user (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5147 {
5148 switch (hashfile_format)
5149 {
5150 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5151 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5152 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5153 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5154 }
5155 }
5156
5157 static uint hlfmt_detect (FILE *fp, uint max_check)
5158 {
5159 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5160
5161 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5162 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5163
5164 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5165
5166 uint num_check = 0;
5167
5168 while (!feof (fp))
5169 {
5170 char line_buf[BUFSIZ] = { 0 };
5171
5172 int line_len = fgetl (fp, line_buf);
5173
5174 if (line_len == 0) continue;
5175
5176 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5177 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5178 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5179
5180 if (num_check == max_check) break;
5181
5182 num_check++;
5183 }
5184
5185 uint hashlist_format = HLFMT_HASHCAT;
5186
5187 for (int i = 1; i < HLFMTS_CNT; i++)
5188 {
5189 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5190
5191 hashlist_format = i;
5192 }
5193
5194 free (formats_cnt);
5195
5196 return hashlist_format;
5197 }
5198
5199 /**
5200 * some further helper function
5201 */
5202
5203 // wrapper around mymalloc for ADL
5204
5205 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5206 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5207 {
5208 return mymalloc (iSize);
5209 }
5210 #endif
5211
5212 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)
5213 {
5214 u64 collisions = 0;
5215
5216 const uint dgst_pos0 = data.dgst_pos0;
5217 const uint dgst_pos1 = data.dgst_pos1;
5218 const uint dgst_pos2 = data.dgst_pos2;
5219 const uint dgst_pos3 = data.dgst_pos3;
5220
5221 memset (bitmap_a, 0, bitmap_size);
5222 memset (bitmap_b, 0, bitmap_size);
5223 memset (bitmap_c, 0, bitmap_size);
5224 memset (bitmap_d, 0, bitmap_size);
5225
5226 for (uint i = 0; i < digests_cnt; i++)
5227 {
5228 uint *digest_ptr = (uint *) digests_buf_ptr;
5229
5230 digests_buf_ptr += dgst_size;
5231
5232 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5233 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5234 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5235 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5236
5237 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5238 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5239 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5240 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5241
5242 if (bitmap_a[idx0] & val0) collisions++;
5243 if (bitmap_b[idx1] & val1) collisions++;
5244 if (bitmap_c[idx2] & val2) collisions++;
5245 if (bitmap_d[idx3] & val3) collisions++;
5246
5247 bitmap_a[idx0] |= val0;
5248 bitmap_b[idx1] |= val1;
5249 bitmap_c[idx2] |= val2;
5250 bitmap_d[idx3] |= val3;
5251
5252 if (collisions >= collisions_max) return 0x7fffffff;
5253 }
5254
5255 return collisions;
5256 }
5257
5258 /**
5259 * main
5260 */
5261
5262 int main (int argc, char **argv)
5263 {
5264 /**
5265 * To help users a bit
5266 */
5267
5268 char *compute = getenv ("COMPUTE");
5269
5270 if (compute)
5271 {
5272 static char display[100];
5273
5274 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5275
5276 putenv (display);
5277 }
5278 else
5279 {
5280 if (getenv ("DISPLAY") == NULL)
5281 putenv ((char *) "DISPLAY=:0");
5282 }
5283
5284 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5285 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5286
5287 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5288 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5289
5290 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5291 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5292
5293 /**
5294 * Real init
5295 */
5296
5297 memset (&data, 0, sizeof (hc_global_data_t));
5298
5299 time_t proc_start;
5300
5301 time (&proc_start);
5302
5303 data.proc_start = proc_start;
5304
5305 int myargc = argc;
5306 char **myargv = argv;
5307
5308 hc_thread_mutex_init (mux_dispatcher);
5309 hc_thread_mutex_init (mux_counter);
5310 hc_thread_mutex_init (mux_display);
5311 hc_thread_mutex_init (mux_adl);
5312
5313 /**
5314 * commandline parameters
5315 */
5316
5317 uint usage = USAGE;
5318 uint version = VERSION;
5319 uint quiet = QUIET;
5320 uint benchmark = BENCHMARK;
5321 uint benchmark_repeats = BENCHMARK_REPEATS;
5322 uint show = SHOW;
5323 uint left = LEFT;
5324 uint username = USERNAME;
5325 uint remove = REMOVE;
5326 uint remove_timer = REMOVE_TIMER;
5327 u64 skip = SKIP;
5328 u64 limit = LIMIT;
5329 uint keyspace = KEYSPACE;
5330 uint potfile_disable = POTFILE_DISABLE;
5331 uint debug_mode = DEBUG_MODE;
5332 char *debug_file = NULL;
5333 char *induction_dir = NULL;
5334 char *outfile_check_dir = NULL;
5335 uint force = FORCE;
5336 uint runtime = RUNTIME;
5337 uint hash_mode = HASH_MODE;
5338 uint attack_mode = ATTACK_MODE;
5339 uint markov_disable = MARKOV_DISABLE;
5340 uint markov_classic = MARKOV_CLASSIC;
5341 uint markov_threshold = MARKOV_THRESHOLD;
5342 char *markov_hcstat = NULL;
5343 char *outfile = NULL;
5344 uint outfile_format = OUTFILE_FORMAT;
5345 uint outfile_autohex = OUTFILE_AUTOHEX;
5346 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5347 uint restore = RESTORE;
5348 uint restore_timer = RESTORE_TIMER;
5349 uint restore_disable = RESTORE_DISABLE;
5350 uint status = STATUS;
5351 uint status_timer = STATUS_TIMER;
5352 uint status_automat = STATUS_AUTOMAT;
5353 uint loopback = LOOPBACK;
5354 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5355 char *session = NULL;
5356 uint hex_charset = HEX_CHARSET;
5357 uint hex_salt = HEX_SALT;
5358 uint hex_wordlist = HEX_WORDLIST;
5359 uint rp_gen = RP_GEN;
5360 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5361 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5362 uint rp_gen_seed = RP_GEN_SEED;
5363 char *rule_buf_l = (char *) RULE_BUF_L;
5364 char *rule_buf_r = (char *) RULE_BUF_R;
5365 uint increment = INCREMENT;
5366 uint increment_min = INCREMENT_MIN;
5367 uint increment_max = INCREMENT_MAX;
5368 char *cpu_affinity = NULL;
5369 OCL_PTR *ocl = NULL;
5370 char *opencl_devices = NULL;
5371 char *opencl_platforms = NULL;
5372 char *opencl_device_types = NULL;
5373 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5374 char *truecrypt_keyfiles = NULL;
5375 uint workload_profile = WORKLOAD_PROFILE;
5376 uint kernel_accel = KERNEL_ACCEL;
5377 uint kernel_loops = KERNEL_LOOPS;
5378 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5379 #ifdef HAVE_HWMON
5380 uint gpu_temp_abort = GPU_TEMP_ABORT;
5381 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5382 #ifdef HAVE_ADL
5383 uint powertune_enable = POWERTUNE_ENABLE;
5384 #endif
5385 #endif
5386 uint logfile_disable = LOGFILE_DISABLE;
5387 uint segment_size = SEGMENT_SIZE;
5388 uint scrypt_tmto = SCRYPT_TMTO;
5389 char separator = SEPARATOR;
5390 uint bitmap_min = BITMAP_MIN;
5391 uint bitmap_max = BITMAP_MAX;
5392 char *custom_charset_1 = NULL;
5393 char *custom_charset_2 = NULL;
5394 char *custom_charset_3 = NULL;
5395 char *custom_charset_4 = NULL;
5396
5397 #define IDX_HELP 'h'
5398 #define IDX_VERSION 'V'
5399 #define IDX_VERSION_LOWER 'v'
5400 #define IDX_QUIET 0xff02
5401 #define IDX_SHOW 0xff03
5402 #define IDX_LEFT 0xff04
5403 #define IDX_REMOVE 0xff05
5404 #define IDX_REMOVE_TIMER 0xff37
5405 #define IDX_SKIP 's'
5406 #define IDX_LIMIT 'l'
5407 #define IDX_KEYSPACE 0xff35
5408 #define IDX_POTFILE_DISABLE 0xff06
5409 #define IDX_DEBUG_MODE 0xff43
5410 #define IDX_DEBUG_FILE 0xff44
5411 #define IDX_INDUCTION_DIR 0xff46
5412 #define IDX_OUTFILE_CHECK_DIR 0xff47
5413 #define IDX_USERNAME 0xff07
5414 #define IDX_FORCE 0xff08
5415 #define IDX_RUNTIME 0xff09
5416 #define IDX_BENCHMARK 'b'
5417 #define IDX_BENCHMARK_REPEATS 0xff78
5418 #define IDX_HASH_MODE 'm'
5419 #define IDX_ATTACK_MODE 'a'
5420 #define IDX_RP_FILE 'r'
5421 #define IDX_RP_GEN 'g'
5422 #define IDX_RP_GEN_FUNC_MIN 0xff10
5423 #define IDX_RP_GEN_FUNC_MAX 0xff11
5424 #define IDX_RP_GEN_SEED 0xff34
5425 #define IDX_RULE_BUF_L 'j'
5426 #define IDX_RULE_BUF_R 'k'
5427 #define IDX_INCREMENT 'i'
5428 #define IDX_INCREMENT_MIN 0xff12
5429 #define IDX_INCREMENT_MAX 0xff13
5430 #define IDX_OUTFILE 'o'
5431 #define IDX_OUTFILE_FORMAT 0xff14
5432 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5433 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5434 #define IDX_RESTORE 0xff15
5435 #define IDX_RESTORE_DISABLE 0xff27
5436 #define IDX_STATUS 0xff17
5437 #define IDX_STATUS_TIMER 0xff18
5438 #define IDX_STATUS_AUTOMAT 0xff50
5439 #define IDX_LOOPBACK 0xff38
5440 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5441 #define IDX_SESSION 0xff19
5442 #define IDX_HEX_CHARSET 0xff20
5443 #define IDX_HEX_SALT 0xff21
5444 #define IDX_HEX_WORDLIST 0xff40
5445 #define IDX_MARKOV_DISABLE 0xff22
5446 #define IDX_MARKOV_CLASSIC 0xff23
5447 #define IDX_MARKOV_THRESHOLD 't'
5448 #define IDX_MARKOV_HCSTAT 0xff24
5449 #define IDX_CPU_AFFINITY 0xff25
5450 #define IDX_OPENCL_DEVICES 'd'
5451 #define IDX_OPENCL_PLATFORMS 0xff72
5452 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5453 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5454 #define IDX_WORKLOAD_PROFILE 'w'
5455 #define IDX_KERNEL_ACCEL 'n'
5456 #define IDX_KERNEL_LOOPS 'u'
5457 #define IDX_GPU_TEMP_DISABLE 0xff29
5458 #define IDX_GPU_TEMP_ABORT 0xff30
5459 #define IDX_GPU_TEMP_RETAIN 0xff31
5460 #define IDX_POWERTUNE_ENABLE 0xff41
5461 #define IDX_LOGFILE_DISABLE 0xff51
5462 #define IDX_TRUECRYPT_KEYFILES 0xff52
5463 #define IDX_SCRYPT_TMTO 0xff61
5464 #define IDX_SEGMENT_SIZE 'c'
5465 #define IDX_SEPARATOR 'p'
5466 #define IDX_BITMAP_MIN 0xff70
5467 #define IDX_BITMAP_MAX 0xff71
5468 #define IDX_CUSTOM_CHARSET_1 '1'
5469 #define IDX_CUSTOM_CHARSET_2 '2'
5470 #define IDX_CUSTOM_CHARSET_3 '3'
5471 #define IDX_CUSTOM_CHARSET_4 '4'
5472
5473 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5474
5475 struct option long_options[] =
5476 {
5477 {"help", no_argument, 0, IDX_HELP},
5478 {"version", no_argument, 0, IDX_VERSION},
5479 {"quiet", no_argument, 0, IDX_QUIET},
5480 {"show", no_argument, 0, IDX_SHOW},
5481 {"left", no_argument, 0, IDX_LEFT},
5482 {"username", no_argument, 0, IDX_USERNAME},
5483 {"remove", no_argument, 0, IDX_REMOVE},
5484 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5485 {"skip", required_argument, 0, IDX_SKIP},
5486 {"limit", required_argument, 0, IDX_LIMIT},
5487 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5488 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5489 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5490 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5491 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5492 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5493 {"force", no_argument, 0, IDX_FORCE},
5494 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5495 {"benchmark-repeats", required_argument, 0, IDX_BENCHMARK_REPEATS},
5496 {"restore", no_argument, 0, IDX_RESTORE},
5497 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5498 {"status", no_argument, 0, IDX_STATUS},
5499 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5500 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5501 {"loopback", no_argument, 0, IDX_LOOPBACK},
5502 {"weak-hash-threshold",
5503 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5504 {"session", required_argument, 0, IDX_SESSION},
5505 {"runtime", required_argument, 0, IDX_RUNTIME},
5506 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5507 {"generate-rules-func-min",
5508 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5509 {"generate-rules-func-max",
5510 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5511 {"generate-rules-seed",
5512 required_argument, 0, IDX_RP_GEN_SEED},
5513 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5514 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5515 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5516 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5517 {"rules-file", required_argument, 0, IDX_RP_FILE},
5518 {"outfile", required_argument, 0, IDX_OUTFILE},
5519 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5520 {"outfile-autohex-disable",
5521 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5522 {"outfile-check-timer",
5523 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5524 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5525 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5526 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5527 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5528 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5529 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5530 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5531 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5532 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5533 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5534 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5535 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5536 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5537 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5538 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5539 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5540 #ifdef HAVE_HWMON
5541 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5542 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5543 #ifdef HAVE_ADL
5544 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5545 #endif
5546 #endif // HAVE_HWMON
5547 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5548 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5549 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5550 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5551 // deprecated
5552 {"seperator", required_argument, 0, IDX_SEPARATOR},
5553 {"separator", required_argument, 0, IDX_SEPARATOR},
5554 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5555 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5556 {"increment", no_argument, 0, IDX_INCREMENT},
5557 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5558 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5559 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5560 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5561 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5562 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5563
5564 {0, 0, 0, 0}
5565 };
5566
5567 uint rp_files_cnt = 0;
5568
5569 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5570
5571 int option_index = 0;
5572 int c = -1;
5573
5574 optind = 1;
5575 optopt = 0;
5576
5577 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5578 {
5579 switch (c)
5580 {
5581 case IDX_HELP: usage = 1; break;
5582 case IDX_VERSION:
5583 case IDX_VERSION_LOWER: version = 1; break;
5584 case IDX_RESTORE: restore = 1; break;
5585 case IDX_SESSION: session = optarg; break;
5586 case IDX_SHOW: show = 1; break;
5587 case IDX_LEFT: left = 1; break;
5588 case '?': return (-1);
5589 }
5590 }
5591
5592 if (optopt != 0)
5593 {
5594 log_error ("ERROR: Invalid argument specified");
5595
5596 return (-1);
5597 }
5598
5599 /**
5600 * exit functions
5601 */
5602
5603 if (version)
5604 {
5605 log_info ("%s (%s)", VERSION_TAG, VERSION_SUM);
5606
5607 return (0);
5608 }
5609
5610 if (usage)
5611 {
5612 usage_big_print (PROGNAME);
5613
5614 return (0);
5615 }
5616
5617 /**
5618 * session needs to be set, always!
5619 */
5620
5621 if (session == NULL) session = (char *) PROGNAME;
5622
5623 /**
5624 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5625 */
5626
5627 char *exec_path = get_exec_path ();
5628
5629 #ifdef LINUX
5630
5631 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5632 char *resolved_exec_path = realpath (exec_path, NULL);
5633
5634 char *install_dir = get_install_dir (resolved_exec_path);
5635 char *profile_dir = NULL;
5636 char *session_dir = NULL;
5637 char *shared_dir = NULL;
5638
5639 if (strcmp (install_dir, resolved_install_folder) == 0)
5640 {
5641 struct passwd *pw = getpwuid (getuid ());
5642
5643 const char *homedir = pw->pw_dir;
5644
5645 profile_dir = get_profile_dir (homedir);
5646 session_dir = get_session_dir (profile_dir);
5647 shared_dir = strdup (SHARED_FOLDER);
5648
5649 mkdir (profile_dir, 0700);
5650 mkdir (session_dir, 0700);
5651 }
5652 else
5653 {
5654 profile_dir = install_dir;
5655 session_dir = install_dir;
5656 shared_dir = install_dir;
5657 }
5658
5659 myfree (resolved_install_folder);
5660 myfree (resolved_exec_path);
5661
5662 #else
5663
5664 char *install_dir = get_install_dir (exec_path);
5665 char *profile_dir = install_dir;
5666 char *session_dir = install_dir;
5667 char *shared_dir = install_dir;
5668
5669 #endif
5670
5671 data.install_dir = install_dir;
5672 data.profile_dir = profile_dir;
5673 data.session_dir = session_dir;
5674 data.shared_dir = shared_dir;
5675
5676 myfree (exec_path);
5677
5678 /**
5679 * kernel cache, we need to make sure folder exist
5680 */
5681
5682 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5683
5684 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5685
5686 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5687
5688 mkdir (kernels_folder, 0700);
5689
5690 myfree (kernels_folder);
5691
5692 /**
5693 * session
5694 */
5695
5696 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5697
5698 data.session = session;
5699
5700 char *eff_restore_file = (char *) mymalloc (session_size);
5701 char *new_restore_file = (char *) mymalloc (session_size);
5702
5703 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5704 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5705
5706 data.eff_restore_file = eff_restore_file;
5707 data.new_restore_file = new_restore_file;
5708
5709 if (((show == 1) || (left == 1)) && (restore == 1))
5710 {
5711 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5712 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5713
5714 return (-1);
5715 }
5716
5717 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5718 if ((show == 1) || (left == 1))
5719 {
5720 restore_disable = 1;
5721
5722 restore = 0;
5723 }
5724
5725 data.restore_disable = restore_disable;
5726
5727 restore_data_t *rd = init_restore (argc, argv);
5728
5729 data.rd = rd;
5730
5731 /**
5732 * restore file
5733 */
5734
5735 if (restore == 1)
5736 {
5737 read_restore (eff_restore_file, rd);
5738
5739 if (rd->version_bin < RESTORE_MIN)
5740 {
5741 log_error ("ERROR: Incompatible restore-file version");
5742
5743 return (-1);
5744 }
5745
5746 myargc = rd->argc;
5747 myargv = rd->argv;
5748
5749 #ifdef _POSIX
5750 rd->pid = getpid ();
5751 #elif _WIN
5752 rd->pid = GetCurrentProcessId ();
5753 #endif
5754 }
5755
5756 uint hash_mode_chgd = 0;
5757 uint runtime_chgd = 0;
5758 uint kernel_loops_chgd = 0;
5759 uint kernel_accel_chgd = 0;
5760 uint attack_mode_chgd = 0;
5761 uint outfile_format_chgd = 0;
5762 uint rp_gen_seed_chgd = 0;
5763 uint remove_timer_chgd = 0;
5764 uint increment_min_chgd = 0;
5765 uint increment_max_chgd = 0;
5766 uint workload_profile_chgd = 0;
5767 uint opencl_vector_width_chgd = 0;
5768
5769 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5770 uint gpu_temp_retain_chgd = 0;
5771 uint gpu_temp_abort_chgd = 0;
5772 #endif
5773
5774 optind = 1;
5775 optopt = 0;
5776 option_index = 0;
5777
5778 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5779 {
5780 switch (c)
5781 {
5782 //case IDX_HELP: usage = 1; break;
5783 //case IDX_VERSION: version = 1; break;
5784 //case IDX_RESTORE: restore = 1; break;
5785 case IDX_QUIET: quiet = 1; break;
5786 //case IDX_SHOW: show = 1; break;
5787 case IDX_SHOW: break;
5788 //case IDX_LEFT: left = 1; break;
5789 case IDX_LEFT: break;
5790 case IDX_USERNAME: username = 1; break;
5791 case IDX_REMOVE: remove = 1; break;
5792 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5793 remove_timer_chgd = 1; break;
5794 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5795 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5796 case IDX_DEBUG_FILE: debug_file = optarg; break;
5797 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5798 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5799 case IDX_FORCE: force = 1; break;
5800 case IDX_SKIP: skip = atoll (optarg); break;
5801 case IDX_LIMIT: limit = atoll (optarg); break;
5802 case IDX_KEYSPACE: keyspace = 1; break;
5803 case IDX_BENCHMARK: benchmark = 1; break;
5804 case IDX_BENCHMARK_REPEATS: benchmark_repeats = atoi (optarg); break;
5805 case IDX_RESTORE: break;
5806 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5807 case IDX_STATUS: status = 1; break;
5808 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5809 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5810 case IDX_LOOPBACK: loopback = 1; break;
5811 case IDX_WEAK_HASH_THRESHOLD:
5812 weak_hash_threshold = atoi (optarg); break;
5813 //case IDX_SESSION: session = optarg; break;
5814 case IDX_SESSION: break;
5815 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5816 hash_mode_chgd = 1; break;
5817 case IDX_RUNTIME: runtime = atoi (optarg);
5818 runtime_chgd = 1; break;
5819 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5820 attack_mode_chgd = 1; break;
5821 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5822 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5823 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5824 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5825 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5826 rp_gen_seed_chgd = 1; break;
5827 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5828 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5829 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5830 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5831 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5832 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5833 case IDX_OUTFILE: outfile = optarg; break;
5834 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5835 outfile_format_chgd = 1; break;
5836 case IDX_OUTFILE_AUTOHEX_DISABLE:
5837 outfile_autohex = 0; break;
5838 case IDX_OUTFILE_CHECK_TIMER:
5839 outfile_check_timer = atoi (optarg); break;
5840 case IDX_HEX_CHARSET: hex_charset = 1; break;
5841 case IDX_HEX_SALT: hex_salt = 1; break;
5842 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5843 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5844 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5845 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5846 case IDX_OPENCL_DEVICE_TYPES:
5847 opencl_device_types = optarg; break;
5848 case IDX_OPENCL_VECTOR_WIDTH:
5849 opencl_vector_width = atoi (optarg);
5850 opencl_vector_width_chgd = 1; break;
5851 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
5852 workload_profile_chgd = 1; break;
5853 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5854 kernel_accel_chgd = 1; break;
5855 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5856 kernel_loops_chgd = 1; break;
5857 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5858 #ifdef HAVE_HWMON
5859 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5860 #ifdef HAVE_ADL
5861 gpu_temp_abort_chgd = 1;
5862 #endif
5863 break;
5864 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5865 #ifdef HAVE_ADL
5866 gpu_temp_retain_chgd = 1;
5867 #endif
5868 break;
5869 #ifdef HAVE_ADL
5870 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5871 #endif
5872 #endif // HAVE_HWMON
5873 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5874 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5875 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5876 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5877 case IDX_SEPARATOR: separator = optarg[0]; break;
5878 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5879 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5880 case IDX_INCREMENT: increment = 1; break;
5881 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5882 increment_min_chgd = 1; break;
5883 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5884 increment_max_chgd = 1; break;
5885 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5886 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5887 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5888 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5889
5890 default:
5891 log_error ("ERROR: Invalid argument specified");
5892 return (-1);
5893 }
5894 }
5895
5896 if (optopt != 0)
5897 {
5898 log_error ("ERROR: Invalid argument specified");
5899
5900 return (-1);
5901 }
5902
5903 /**
5904 * Inform user things getting started,
5905 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5906 * - we do not need to check algorithm_pos
5907 */
5908
5909 if (quiet == 0)
5910 {
5911 if (benchmark == 1)
5912 {
5913 log_info ("%s %s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5914
5915 log_info ("");
5916 }
5917 else if (restore == 1)
5918 {
5919 log_info ("%s %s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5920
5921 log_info ("");
5922 }
5923 else
5924 {
5925 log_info ("%s %s (%s) starting...", PROGNAME, VERSION_TAG, VERSION_SUM);
5926
5927 log_info ("");
5928 }
5929 }
5930
5931 /**
5932 * sanity check
5933 */
5934
5935 if (attack_mode > 7)
5936 {
5937 log_error ("ERROR: Invalid attack-mode specified");
5938
5939 return (-1);
5940 }
5941
5942 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5943 {
5944 log_error ("ERROR: Invalid runtime specified");
5945
5946 return (-1);
5947 }
5948
5949 if (hash_mode_chgd && hash_mode > 13100) // just added to remove compiler warnings for hash_mode_chgd
5950 {
5951 log_error ("ERROR: Invalid hash-type specified");
5952
5953 return (-1);
5954 }
5955
5956 // renamed hash modes
5957
5958 if (hash_mode_chgd)
5959 {
5960 int n = -1;
5961
5962 switch (hash_mode)
5963 {
5964 case 123: n = 124;
5965 break;
5966 }
5967
5968 if (n >= 0)
5969 {
5970 log_error ("Old -m specified, use -m %d instead", n);
5971
5972 return (-1);
5973 }
5974 }
5975
5976 if (username == 1)
5977 {
5978 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
5979 {
5980 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5981
5982 return (-1);
5983 }
5984 }
5985
5986 if (outfile_format > 16)
5987 {
5988 log_error ("ERROR: Invalid outfile-format specified");
5989
5990 return (-1);
5991 }
5992
5993 if (left == 1)
5994 {
5995 if (outfile_format_chgd == 1)
5996 {
5997 if (outfile_format > 1)
5998 {
5999 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6000
6001 return (-1);
6002 }
6003 }
6004 else
6005 {
6006 outfile_format = OUTFILE_FMT_HASH;
6007 }
6008 }
6009
6010 if (show == 1)
6011 {
6012 if (outfile_format_chgd == 1)
6013 {
6014 if ((outfile_format > 7) && (outfile_format < 16))
6015 {
6016 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6017
6018 return (-1);
6019 }
6020 }
6021 }
6022
6023 if (increment_min < INCREMENT_MIN)
6024 {
6025 log_error ("ERROR: Invalid increment-min specified");
6026
6027 return (-1);
6028 }
6029
6030 if (increment_max > INCREMENT_MAX)
6031 {
6032 log_error ("ERROR: Invalid increment-max specified");
6033
6034 return (-1);
6035 }
6036
6037 if (increment_min > increment_max)
6038 {
6039 log_error ("ERROR: Invalid increment-min specified");
6040
6041 return (-1);
6042 }
6043
6044 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6045 {
6046 log_error ("ERROR: increment is not allowed in attack-mode 0");
6047
6048 return (-1);
6049 }
6050
6051 if ((increment == 0) && (increment_min_chgd == 1))
6052 {
6053 log_error ("ERROR: increment-min is only supported together with increment switch");
6054
6055 return (-1);
6056 }
6057
6058 if ((increment == 0) && (increment_max_chgd == 1))
6059 {
6060 log_error ("ERROR: increment-max is only supported together with increment switch");
6061
6062 return (-1);
6063 }
6064
6065 if (rp_files_cnt && rp_gen)
6066 {
6067 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6068
6069 return (-1);
6070 }
6071
6072 if (rp_files_cnt || rp_gen)
6073 {
6074 if (attack_mode != ATTACK_MODE_STRAIGHT)
6075 {
6076 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6077
6078 return (-1);
6079 }
6080 }
6081
6082 if (rp_gen_func_min > rp_gen_func_max)
6083 {
6084 log_error ("ERROR: Invalid rp-gen-func-min specified");
6085
6086 return (-1);
6087 }
6088
6089 if (kernel_accel_chgd == 1)
6090 {
6091 if (kernel_accel < 1)
6092 {
6093 log_error ("ERROR: Invalid kernel-accel specified");
6094
6095 return (-1);
6096 }
6097
6098 if (kernel_accel > 1024)
6099 {
6100 log_error ("ERROR: Invalid kernel-accel specified");
6101
6102 return (-1);
6103 }
6104 }
6105
6106 if (kernel_loops_chgd == 1)
6107 {
6108 if (kernel_loops < 1)
6109 {
6110 log_error ("ERROR: Invalid kernel-loops specified");
6111
6112 return (-1);
6113 }
6114
6115 if (kernel_loops > 1024)
6116 {
6117 log_error ("ERROR: Invalid kernel-loops specified");
6118
6119 return (-1);
6120 }
6121 }
6122
6123 if ((workload_profile < 1) || (workload_profile > 3))
6124 {
6125 log_error ("ERROR: workload-profile %i not available", workload_profile);
6126
6127 return (-1);
6128 }
6129
6130 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6131 {
6132 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6133
6134 return (-1);
6135 }
6136
6137 if (show == 1 || left == 1)
6138 {
6139 attack_mode = ATTACK_MODE_NONE;
6140
6141 if (remove == 1)
6142 {
6143 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6144
6145 return (-1);
6146 }
6147
6148 if (potfile_disable == 1)
6149 {
6150 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6151
6152 return (-1);
6153 }
6154 }
6155
6156 uint attack_kern = ATTACK_KERN_NONE;
6157
6158 switch (attack_mode)
6159 {
6160 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6161 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6162 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6163 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6164 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6165 }
6166
6167 if (benchmark == 0)
6168 {
6169 if (keyspace == 1)
6170 {
6171 int num_additional_params = 1;
6172
6173 if (attack_kern == ATTACK_KERN_COMBI)
6174 {
6175 num_additional_params = 2;
6176 }
6177
6178 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6179
6180 if (keyspace_wordlist_specified == 0) optind--;
6181 }
6182
6183 if (attack_kern == ATTACK_KERN_NONE)
6184 {
6185 if ((optind + 1) != myargc)
6186 {
6187 usage_mini_print (myargv[0]);
6188
6189 return (-1);
6190 }
6191 }
6192 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6193 {
6194 if ((optind + 1) > myargc)
6195 {
6196 usage_mini_print (myargv[0]);
6197
6198 return (-1);
6199 }
6200 }
6201 else if (attack_kern == ATTACK_KERN_COMBI)
6202 {
6203 if ((optind + 3) != myargc)
6204 {
6205 usage_mini_print (myargv[0]);
6206
6207 return (-1);
6208 }
6209 }
6210 else if (attack_kern == ATTACK_KERN_BF)
6211 {
6212 if ((optind + 1) > myargc)
6213 {
6214 usage_mini_print (myargv[0]);
6215
6216 return (-1);
6217 }
6218 }
6219 else
6220 {
6221 usage_mini_print (myargv[0]);
6222
6223 return (-1);
6224 }
6225 }
6226 else
6227 {
6228 if (myargv[optind] != 0)
6229 {
6230 log_error ("ERROR: Invalid argument for benchmark mode specified");
6231
6232 return (-1);
6233 }
6234
6235 if (attack_mode_chgd == 1)
6236 {
6237 if (attack_mode != ATTACK_MODE_BF)
6238 {
6239 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6240
6241 return (-1);
6242 }
6243 }
6244 }
6245
6246 if (skip != 0 && limit != 0)
6247 {
6248 limit += skip;
6249 }
6250
6251 if (keyspace == 1)
6252 {
6253 if (show == 1)
6254 {
6255 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6256
6257 return (-1);
6258 }
6259 else if (left == 1)
6260 {
6261 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6262
6263 return (-1);
6264 }
6265
6266 potfile_disable = 1;
6267
6268 restore_disable = 1;
6269
6270 restore = 0;
6271
6272 weak_hash_threshold = 0;
6273
6274 quiet = 1;
6275 }
6276
6277 if (remove_timer_chgd == 1)
6278 {
6279 if (remove == 0)
6280 {
6281 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6282
6283 return (-1);
6284 }
6285
6286 if (remove_timer < 1)
6287 {
6288 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6289
6290 return (-1);
6291 }
6292 }
6293
6294 if (loopback == 1)
6295 {
6296 if (attack_mode == ATTACK_MODE_BF)
6297 {
6298 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
6299
6300 return (-1);
6301 }
6302 else if (attack_mode == ATTACK_MODE_STRAIGHT)
6303 {
6304 if ((rp_files_cnt == 0) && (rp_gen == 0))
6305 {
6306 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6307
6308 return (-1);
6309 }
6310 }
6311 }
6312
6313 if (debug_mode > 0)
6314 {
6315 if (attack_mode != ATTACK_MODE_STRAIGHT)
6316 {
6317 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6318
6319 return (-1);
6320 }
6321
6322 if ((rp_files_cnt == 0) && (rp_gen == 0))
6323 {
6324 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6325
6326 return (-1);
6327 }
6328 }
6329
6330 if (debug_mode > 4)
6331 {
6332 log_error ("ERROR: Invalid debug-mode specified");
6333
6334 return (-1);
6335 }
6336
6337 if (debug_file != NULL)
6338 {
6339 if (debug_mode < 1)
6340 {
6341 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6342
6343 return (-1);
6344 }
6345 }
6346
6347 if (induction_dir != NULL)
6348 {
6349 if (attack_mode == ATTACK_MODE_BF)
6350 {
6351 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6352
6353 return (-1);
6354 }
6355 }
6356
6357 if (attack_mode != ATTACK_MODE_STRAIGHT)
6358 {
6359 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6360 {
6361 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6362
6363 return (-1);
6364 }
6365
6366 weak_hash_threshold = 0;
6367 }
6368
6369 /**
6370 * induction directory
6371 */
6372
6373 char *induction_directory = NULL;
6374
6375 if (attack_mode != ATTACK_MODE_BF)
6376 {
6377 if (induction_dir == NULL)
6378 {
6379 induction_directory = (char *) mymalloc (session_size);
6380
6381 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6382
6383 // create induction folder if it does not already exist
6384
6385 if (keyspace == 0)
6386 {
6387 if (rmdir (induction_directory) == -1)
6388 {
6389 if (errno == ENOENT)
6390 {
6391 // good, we can ignore
6392 }
6393 else if (errno == ENOTEMPTY)
6394 {
6395 char *induction_directory_mv = (char *) mymalloc (session_size);
6396
6397 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6398
6399 if (rename (induction_directory, induction_directory_mv) != 0)
6400 {
6401 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6402
6403 return (-1);
6404 }
6405 }
6406 else
6407 {
6408 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6409
6410 return (-1);
6411 }
6412 }
6413
6414 if (mkdir (induction_directory, 0700) == -1)
6415 {
6416 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6417
6418 return (-1);
6419 }
6420 }
6421 }
6422 else
6423 {
6424 induction_directory = induction_dir;
6425 }
6426 }
6427
6428 data.induction_directory = induction_directory;
6429
6430 /**
6431 * loopback
6432 */
6433
6434 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6435
6436 char *loopback_file = (char *) mymalloc (loopback_size);
6437
6438 /**
6439 * tuning db
6440 */
6441
6442 char tuning_db_file[256] = { 0 };
6443
6444 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6445
6446 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6447
6448 /**
6449 * outfile-check directory
6450 */
6451
6452 char *outfile_check_directory = NULL;
6453
6454 if (outfile_check_dir == NULL)
6455 {
6456 outfile_check_directory = (char *) mymalloc (session_size);
6457
6458 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6459 }
6460 else
6461 {
6462 outfile_check_directory = outfile_check_dir;
6463 }
6464
6465 data.outfile_check_directory = outfile_check_directory;
6466
6467 if (keyspace == 0)
6468 {
6469 struct stat outfile_check_stat;
6470
6471 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6472 {
6473 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6474
6475 if (is_dir == 0)
6476 {
6477 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6478
6479 return (-1);
6480 }
6481 }
6482 else if (outfile_check_dir == NULL)
6483 {
6484 if (mkdir (outfile_check_directory, 0700) == -1)
6485 {
6486 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6487
6488 return (-1);
6489 }
6490 }
6491 }
6492
6493 /**
6494 * special other stuff
6495 */
6496
6497 if (hash_mode == 9710)
6498 {
6499 outfile_format = 5;
6500 outfile_format_chgd = 1;
6501 }
6502
6503 if (hash_mode == 9810)
6504 {
6505 outfile_format = 5;
6506 outfile_format_chgd = 1;
6507 }
6508
6509 if (hash_mode == 10410)
6510 {
6511 outfile_format = 5;
6512 outfile_format_chgd = 1;
6513 }
6514
6515 /**
6516 * store stuff
6517 */
6518
6519 data.hash_mode = hash_mode;
6520 data.restore = restore;
6521 data.restore_timer = restore_timer;
6522 data.restore_disable = restore_disable;
6523 data.status = status;
6524 data.status_timer = status_timer;
6525 data.status_automat = status_automat;
6526 data.loopback = loopback;
6527 data.runtime = runtime;
6528 data.remove = remove;
6529 data.remove_timer = remove_timer;
6530 data.debug_mode = debug_mode;
6531 data.debug_file = debug_file;
6532 data.username = username;
6533 data.quiet = quiet;
6534 data.outfile = outfile;
6535 data.outfile_format = outfile_format;
6536 data.outfile_autohex = outfile_autohex;
6537 data.hex_charset = hex_charset;
6538 data.hex_salt = hex_salt;
6539 data.hex_wordlist = hex_wordlist;
6540 data.separator = separator;
6541 data.rp_files = rp_files;
6542 data.rp_files_cnt = rp_files_cnt;
6543 data.rp_gen = rp_gen;
6544 data.rp_gen_seed = rp_gen_seed;
6545 data.force = force;
6546 data.benchmark = benchmark;
6547 data.benchmark_repeats = benchmark_repeats;
6548 data.skip = skip;
6549 data.limit = limit;
6550 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6551 data.powertune_enable = powertune_enable;
6552 #endif
6553 data.logfile_disable = logfile_disable;
6554 data.truecrypt_keyfiles = truecrypt_keyfiles;
6555 data.scrypt_tmto = scrypt_tmto;
6556 data.workload_profile = workload_profile;
6557
6558 /**
6559 * cpu affinity
6560 */
6561
6562 if (cpu_affinity)
6563 {
6564 set_cpu_affinity (cpu_affinity);
6565 }
6566
6567 if (rp_gen_seed_chgd == 0)
6568 {
6569 srand (proc_start);
6570 }
6571 else
6572 {
6573 srand (rp_gen_seed);
6574 }
6575
6576 /**
6577 * logfile init
6578 */
6579
6580 if (logfile_disable == 0)
6581 {
6582 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6583
6584 char *logfile = (char *) mymalloc (logfile_size);
6585
6586 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6587
6588 data.logfile = logfile;
6589
6590 char *topid = logfile_generate_topid ();
6591
6592 data.topid = topid;
6593 }
6594
6595 // logfile_append() checks for logfile_disable internally to make it easier from here
6596
6597 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6598 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6599 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6600 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6601 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6602 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6603 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6604 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6605 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6606 #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));
6607
6608 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6609 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6610 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6611 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6612 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6613 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6614 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6615 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6616
6617 logfile_top_msg ("START");
6618
6619 logfile_top_uint (attack_mode);
6620 logfile_top_uint (attack_kern);
6621 logfile_top_uint (benchmark);
6622 logfile_top_uint (benchmark_repeats);
6623 logfile_top_uint (bitmap_min);
6624 logfile_top_uint (bitmap_max);
6625 logfile_top_uint (debug_mode);
6626 logfile_top_uint (force);
6627 logfile_top_uint (kernel_accel);
6628 logfile_top_uint (kernel_loops);
6629 logfile_top_uint (gpu_temp_disable);
6630 #ifdef HAVE_HWMON
6631 logfile_top_uint (gpu_temp_abort);
6632 logfile_top_uint (gpu_temp_retain);
6633 #endif
6634 logfile_top_uint (hash_mode);
6635 logfile_top_uint (hex_charset);
6636 logfile_top_uint (hex_salt);
6637 logfile_top_uint (hex_wordlist);
6638 logfile_top_uint (increment);
6639 logfile_top_uint (increment_max);
6640 logfile_top_uint (increment_min);
6641 logfile_top_uint (keyspace);
6642 logfile_top_uint (left);
6643 logfile_top_uint (logfile_disable);
6644 logfile_top_uint (loopback);
6645 logfile_top_uint (markov_classic);
6646 logfile_top_uint (markov_disable);
6647 logfile_top_uint (markov_threshold);
6648 logfile_top_uint (outfile_autohex);
6649 logfile_top_uint (outfile_check_timer);
6650 logfile_top_uint (outfile_format);
6651 logfile_top_uint (potfile_disable);
6652 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6653 logfile_top_uint (powertune_enable);
6654 #endif
6655 logfile_top_uint (scrypt_tmto);
6656 logfile_top_uint (quiet);
6657 logfile_top_uint (remove);
6658 logfile_top_uint (remove_timer);
6659 logfile_top_uint (restore);
6660 logfile_top_uint (restore_disable);
6661 logfile_top_uint (restore_timer);
6662 logfile_top_uint (rp_gen);
6663 logfile_top_uint (rp_gen_func_max);
6664 logfile_top_uint (rp_gen_func_min);
6665 logfile_top_uint (rp_gen_seed);
6666 logfile_top_uint (runtime);
6667 logfile_top_uint (segment_size);
6668 logfile_top_uint (show);
6669 logfile_top_uint (status);
6670 logfile_top_uint (status_automat);
6671 logfile_top_uint (status_timer);
6672 logfile_top_uint (usage);
6673 logfile_top_uint (username);
6674 logfile_top_uint (version);
6675 logfile_top_uint (weak_hash_threshold);
6676 logfile_top_uint (workload_profile);
6677 logfile_top_uint64 (limit);
6678 logfile_top_uint64 (skip);
6679 logfile_top_char (separator);
6680 logfile_top_string (cpu_affinity);
6681 logfile_top_string (custom_charset_1);
6682 logfile_top_string (custom_charset_2);
6683 logfile_top_string (custom_charset_3);
6684 logfile_top_string (custom_charset_4);
6685 logfile_top_string (debug_file);
6686 logfile_top_string (opencl_devices);
6687 logfile_top_string (opencl_platforms);
6688 logfile_top_string (opencl_device_types);
6689 logfile_top_uint (opencl_vector_width);
6690 logfile_top_string (induction_dir);
6691 logfile_top_string (markov_hcstat);
6692 logfile_top_string (outfile);
6693 logfile_top_string (outfile_check_dir);
6694 logfile_top_string (rule_buf_l);
6695 logfile_top_string (rule_buf_r);
6696 logfile_top_string (session);
6697 logfile_top_string (truecrypt_keyfiles);
6698
6699 /**
6700 * Init OpenCL library loader
6701 */
6702
6703 if (keyspace == 0)
6704 {
6705 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6706
6707 ocl_init (ocl);
6708
6709 data.ocl = ocl;
6710 }
6711
6712 /**
6713 * OpenCL platform selection
6714 */
6715
6716 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6717
6718 /**
6719 * OpenCL device selection
6720 */
6721
6722 u32 devices_filter = setup_devices_filter (opencl_devices);
6723
6724 /**
6725 * OpenCL device type selection
6726 */
6727
6728 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6729
6730 /**
6731 * benchmark
6732 */
6733
6734 if (benchmark == 1)
6735 {
6736 /**
6737 * disable useless stuff for benchmark
6738 */
6739
6740 status_timer = 0;
6741 restore_timer = 0;
6742 restore_disable = 1;
6743 potfile_disable = 1;
6744 weak_hash_threshold = 0;
6745 gpu_temp_disable = 1;
6746
6747 data.status_timer = status_timer;
6748 data.restore_timer = restore_timer;
6749 data.restore_disable = restore_disable;
6750
6751 /**
6752 * force attack mode to be bruteforce
6753 */
6754
6755 attack_mode = ATTACK_MODE_BF;
6756 attack_kern = ATTACK_KERN_BF;
6757
6758 if (workload_profile_chgd == 0)
6759 {
6760 workload_profile = 3;
6761
6762 data.workload_profile = workload_profile;
6763 }
6764 }
6765
6766 /**
6767 * config
6768 */
6769
6770 uint hash_type = 0;
6771 uint salt_type = 0;
6772 uint attack_exec = 0;
6773 uint opts_type = 0;
6774 uint kern_type = 0;
6775 uint dgst_size = 0;
6776 uint esalt_size = 0;
6777 uint opti_type = 0;
6778 uint dgst_pos0 = -1;
6779 uint dgst_pos1 = -1;
6780 uint dgst_pos2 = -1;
6781 uint dgst_pos3 = -1;
6782
6783 int (*parse_func) (char *, uint, hash_t *);
6784 int (*sort_by_digest) (const void *, const void *);
6785
6786 uint algorithm_pos = 0;
6787 uint algorithm_max = 1;
6788
6789 uint *algorithms = default_benchmark_algorithms;
6790
6791 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6792
6793 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6794 {
6795 /*
6796 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6797 * the following algos are skipped entirely
6798 */
6799
6800 if (algorithm_pos > 0)
6801 {
6802 local_free (rd);
6803
6804 rd = init_restore (argc, argv);
6805
6806 data.rd = rd;
6807 }
6808
6809 /**
6810 * update hash_mode in case of multihash benchmark
6811 */
6812
6813 if (benchmark == 1)
6814 {
6815 if (hash_mode_chgd == 0)
6816 {
6817 hash_mode = algorithms[algorithm_pos];
6818
6819 data.hash_mode = hash_mode;
6820 }
6821
6822 quiet = 1;
6823
6824 data.quiet = quiet;
6825 }
6826
6827 switch (hash_mode)
6828 {
6829 case 0: hash_type = HASH_TYPE_MD5;
6830 salt_type = SALT_TYPE_NONE;
6831 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6832 opts_type = OPTS_TYPE_PT_GENERATE_LE
6833 | OPTS_TYPE_PT_ADD80
6834 | OPTS_TYPE_PT_ADDBITS14;
6835 kern_type = KERN_TYPE_MD5;
6836 dgst_size = DGST_SIZE_4_4;
6837 parse_func = md5_parse_hash;
6838 sort_by_digest = sort_by_digest_4_4;
6839 opti_type = OPTI_TYPE_ZERO_BYTE
6840 | OPTI_TYPE_PRECOMPUTE_INIT
6841 | OPTI_TYPE_PRECOMPUTE_MERKLE
6842 | OPTI_TYPE_MEET_IN_MIDDLE
6843 | OPTI_TYPE_EARLY_SKIP
6844 | OPTI_TYPE_NOT_ITERATED
6845 | OPTI_TYPE_NOT_SALTED
6846 | OPTI_TYPE_RAW_HASH;
6847 dgst_pos0 = 0;
6848 dgst_pos1 = 3;
6849 dgst_pos2 = 2;
6850 dgst_pos3 = 1;
6851 break;
6852
6853 case 10: hash_type = HASH_TYPE_MD5;
6854 salt_type = SALT_TYPE_INTERN;
6855 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6856 opts_type = OPTS_TYPE_PT_GENERATE_LE
6857 | OPTS_TYPE_ST_ADD80
6858 | OPTS_TYPE_ST_ADDBITS14;
6859 kern_type = KERN_TYPE_MD5_PWSLT;
6860 dgst_size = DGST_SIZE_4_4;
6861 parse_func = md5s_parse_hash;
6862 sort_by_digest = sort_by_digest_4_4;
6863 opti_type = OPTI_TYPE_ZERO_BYTE
6864 | OPTI_TYPE_PRECOMPUTE_INIT
6865 | OPTI_TYPE_PRECOMPUTE_MERKLE
6866 | OPTI_TYPE_MEET_IN_MIDDLE
6867 | OPTI_TYPE_EARLY_SKIP
6868 | OPTI_TYPE_NOT_ITERATED
6869 | OPTI_TYPE_APPENDED_SALT
6870 | OPTI_TYPE_RAW_HASH;
6871 dgst_pos0 = 0;
6872 dgst_pos1 = 3;
6873 dgst_pos2 = 2;
6874 dgst_pos3 = 1;
6875 break;
6876
6877 case 11: hash_type = HASH_TYPE_MD5;
6878 salt_type = SALT_TYPE_INTERN;
6879 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6880 opts_type = OPTS_TYPE_PT_GENERATE_LE
6881 | OPTS_TYPE_ST_ADD80
6882 | OPTS_TYPE_ST_ADDBITS14;
6883 kern_type = KERN_TYPE_MD5_PWSLT;
6884 dgst_size = DGST_SIZE_4_4;
6885 parse_func = joomla_parse_hash;
6886 sort_by_digest = sort_by_digest_4_4;
6887 opti_type = OPTI_TYPE_ZERO_BYTE
6888 | OPTI_TYPE_PRECOMPUTE_INIT
6889 | OPTI_TYPE_PRECOMPUTE_MERKLE
6890 | OPTI_TYPE_MEET_IN_MIDDLE
6891 | OPTI_TYPE_EARLY_SKIP
6892 | OPTI_TYPE_NOT_ITERATED
6893 | OPTI_TYPE_APPENDED_SALT
6894 | OPTI_TYPE_RAW_HASH;
6895 dgst_pos0 = 0;
6896 dgst_pos1 = 3;
6897 dgst_pos2 = 2;
6898 dgst_pos3 = 1;
6899 break;
6900
6901 case 12: hash_type = HASH_TYPE_MD5;
6902 salt_type = SALT_TYPE_INTERN;
6903 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6904 opts_type = OPTS_TYPE_PT_GENERATE_LE
6905 | OPTS_TYPE_ST_ADD80
6906 | OPTS_TYPE_ST_ADDBITS14;
6907 kern_type = KERN_TYPE_MD5_PWSLT;
6908 dgst_size = DGST_SIZE_4_4;
6909 parse_func = postgresql_parse_hash;
6910 sort_by_digest = sort_by_digest_4_4;
6911 opti_type = OPTI_TYPE_ZERO_BYTE
6912 | OPTI_TYPE_PRECOMPUTE_INIT
6913 | OPTI_TYPE_PRECOMPUTE_MERKLE
6914 | OPTI_TYPE_MEET_IN_MIDDLE
6915 | OPTI_TYPE_EARLY_SKIP
6916 | OPTI_TYPE_NOT_ITERATED
6917 | OPTI_TYPE_APPENDED_SALT
6918 | OPTI_TYPE_RAW_HASH;
6919 dgst_pos0 = 0;
6920 dgst_pos1 = 3;
6921 dgst_pos2 = 2;
6922 dgst_pos3 = 1;
6923 break;
6924
6925 case 20: hash_type = HASH_TYPE_MD5;
6926 salt_type = SALT_TYPE_INTERN;
6927 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6928 opts_type = OPTS_TYPE_PT_GENERATE_LE
6929 | OPTS_TYPE_PT_ADD80
6930 | OPTS_TYPE_PT_ADDBITS14;
6931 kern_type = KERN_TYPE_MD5_SLTPW;
6932 dgst_size = DGST_SIZE_4_4;
6933 parse_func = md5s_parse_hash;
6934 sort_by_digest = sort_by_digest_4_4;
6935 opti_type = OPTI_TYPE_ZERO_BYTE
6936 | OPTI_TYPE_PRECOMPUTE_INIT
6937 | OPTI_TYPE_PRECOMPUTE_MERKLE
6938 | OPTI_TYPE_EARLY_SKIP
6939 | OPTI_TYPE_NOT_ITERATED
6940 | OPTI_TYPE_PREPENDED_SALT
6941 | OPTI_TYPE_RAW_HASH;
6942 dgst_pos0 = 0;
6943 dgst_pos1 = 3;
6944 dgst_pos2 = 2;
6945 dgst_pos3 = 1;
6946 break;
6947
6948 case 21: hash_type = HASH_TYPE_MD5;
6949 salt_type = SALT_TYPE_INTERN;
6950 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6951 opts_type = OPTS_TYPE_PT_GENERATE_LE
6952 | OPTS_TYPE_PT_ADD80
6953 | OPTS_TYPE_PT_ADDBITS14;
6954 kern_type = KERN_TYPE_MD5_SLTPW;
6955 dgst_size = DGST_SIZE_4_4;
6956 parse_func = osc_parse_hash;
6957 sort_by_digest = sort_by_digest_4_4;
6958 opti_type = OPTI_TYPE_ZERO_BYTE
6959 | OPTI_TYPE_PRECOMPUTE_INIT
6960 | OPTI_TYPE_PRECOMPUTE_MERKLE
6961 | OPTI_TYPE_EARLY_SKIP
6962 | OPTI_TYPE_NOT_ITERATED
6963 | OPTI_TYPE_PREPENDED_SALT
6964 | OPTI_TYPE_RAW_HASH;
6965 dgst_pos0 = 0;
6966 dgst_pos1 = 3;
6967 dgst_pos2 = 2;
6968 dgst_pos3 = 1;
6969 break;
6970
6971 case 22: hash_type = HASH_TYPE_MD5;
6972 salt_type = SALT_TYPE_EMBEDDED;
6973 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6974 opts_type = OPTS_TYPE_PT_GENERATE_LE
6975 | OPTS_TYPE_PT_ADD80
6976 | OPTS_TYPE_PT_ADDBITS14;
6977 kern_type = KERN_TYPE_MD5_SLTPW;
6978 dgst_size = DGST_SIZE_4_4;
6979 parse_func = netscreen_parse_hash;
6980 sort_by_digest = sort_by_digest_4_4;
6981 opti_type = OPTI_TYPE_ZERO_BYTE
6982 | OPTI_TYPE_PRECOMPUTE_INIT
6983 | OPTI_TYPE_PRECOMPUTE_MERKLE
6984 | OPTI_TYPE_EARLY_SKIP
6985 | OPTI_TYPE_NOT_ITERATED
6986 | OPTI_TYPE_PREPENDED_SALT
6987 | OPTI_TYPE_RAW_HASH;
6988 dgst_pos0 = 0;
6989 dgst_pos1 = 3;
6990 dgst_pos2 = 2;
6991 dgst_pos3 = 1;
6992 break;
6993
6994 case 23: hash_type = HASH_TYPE_MD5;
6995 salt_type = SALT_TYPE_EMBEDDED;
6996 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6997 opts_type = OPTS_TYPE_PT_GENERATE_LE
6998 | OPTS_TYPE_PT_ADD80
6999 | OPTS_TYPE_PT_ADDBITS14;
7000 kern_type = KERN_TYPE_MD5_SLTPW;
7001 dgst_size = DGST_SIZE_4_4;
7002 parse_func = skype_parse_hash;
7003 sort_by_digest = sort_by_digest_4_4;
7004 opti_type = OPTI_TYPE_ZERO_BYTE
7005 | OPTI_TYPE_PRECOMPUTE_INIT
7006 | OPTI_TYPE_PRECOMPUTE_MERKLE
7007 | OPTI_TYPE_EARLY_SKIP
7008 | OPTI_TYPE_NOT_ITERATED
7009 | OPTI_TYPE_PREPENDED_SALT
7010 | OPTI_TYPE_RAW_HASH;
7011 dgst_pos0 = 0;
7012 dgst_pos1 = 3;
7013 dgst_pos2 = 2;
7014 dgst_pos3 = 1;
7015 break;
7016
7017 case 30: hash_type = HASH_TYPE_MD5;
7018 salt_type = SALT_TYPE_INTERN;
7019 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7020 opts_type = OPTS_TYPE_PT_GENERATE_LE
7021 | OPTS_TYPE_PT_UNICODE
7022 | OPTS_TYPE_ST_ADD80
7023 | OPTS_TYPE_ST_ADDBITS14;
7024 kern_type = KERN_TYPE_MD5_PWUSLT;
7025 dgst_size = DGST_SIZE_4_4;
7026 parse_func = md5s_parse_hash;
7027 sort_by_digest = sort_by_digest_4_4;
7028 opti_type = OPTI_TYPE_ZERO_BYTE
7029 | OPTI_TYPE_PRECOMPUTE_INIT
7030 | OPTI_TYPE_PRECOMPUTE_MERKLE
7031 | OPTI_TYPE_MEET_IN_MIDDLE
7032 | OPTI_TYPE_EARLY_SKIP
7033 | OPTI_TYPE_NOT_ITERATED
7034 | OPTI_TYPE_APPENDED_SALT
7035 | OPTI_TYPE_RAW_HASH;
7036 dgst_pos0 = 0;
7037 dgst_pos1 = 3;
7038 dgst_pos2 = 2;
7039 dgst_pos3 = 1;
7040 break;
7041
7042 case 40: hash_type = HASH_TYPE_MD5;
7043 salt_type = SALT_TYPE_INTERN;
7044 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7045 opts_type = OPTS_TYPE_PT_GENERATE_LE
7046 | OPTS_TYPE_PT_ADD80
7047 | OPTS_TYPE_PT_ADDBITS14
7048 | OPTS_TYPE_PT_UNICODE;
7049 kern_type = KERN_TYPE_MD5_SLTPWU;
7050 dgst_size = DGST_SIZE_4_4;
7051 parse_func = md5s_parse_hash;
7052 sort_by_digest = sort_by_digest_4_4;
7053 opti_type = OPTI_TYPE_ZERO_BYTE
7054 | OPTI_TYPE_PRECOMPUTE_INIT
7055 | OPTI_TYPE_PRECOMPUTE_MERKLE
7056 | OPTI_TYPE_EARLY_SKIP
7057 | OPTI_TYPE_NOT_ITERATED
7058 | OPTI_TYPE_PREPENDED_SALT
7059 | OPTI_TYPE_RAW_HASH;
7060 dgst_pos0 = 0;
7061 dgst_pos1 = 3;
7062 dgst_pos2 = 2;
7063 dgst_pos3 = 1;
7064 break;
7065
7066 case 50: hash_type = HASH_TYPE_MD5;
7067 salt_type = SALT_TYPE_INTERN;
7068 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7069 opts_type = OPTS_TYPE_PT_GENERATE_LE
7070 | OPTS_TYPE_ST_ADD80
7071 | OPTS_TYPE_ST_ADDBITS14;
7072 kern_type = KERN_TYPE_HMACMD5_PW;
7073 dgst_size = DGST_SIZE_4_4;
7074 parse_func = hmacmd5_parse_hash;
7075 sort_by_digest = sort_by_digest_4_4;
7076 opti_type = OPTI_TYPE_ZERO_BYTE
7077 | OPTI_TYPE_NOT_ITERATED;
7078 dgst_pos0 = 0;
7079 dgst_pos1 = 3;
7080 dgst_pos2 = 2;
7081 dgst_pos3 = 1;
7082 break;
7083
7084 case 60: hash_type = HASH_TYPE_MD5;
7085 salt_type = SALT_TYPE_INTERN;
7086 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7087 opts_type = OPTS_TYPE_PT_GENERATE_LE
7088 | OPTS_TYPE_PT_ADD80
7089 | OPTS_TYPE_PT_ADDBITS14;
7090 kern_type = KERN_TYPE_HMACMD5_SLT;
7091 dgst_size = DGST_SIZE_4_4;
7092 parse_func = hmacmd5_parse_hash;
7093 sort_by_digest = sort_by_digest_4_4;
7094 opti_type = OPTI_TYPE_ZERO_BYTE
7095 | OPTI_TYPE_NOT_ITERATED;
7096 dgst_pos0 = 0;
7097 dgst_pos1 = 3;
7098 dgst_pos2 = 2;
7099 dgst_pos3 = 1;
7100 break;
7101
7102 case 100: hash_type = HASH_TYPE_SHA1;
7103 salt_type = SALT_TYPE_NONE;
7104 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7105 opts_type = OPTS_TYPE_PT_GENERATE_BE
7106 | OPTS_TYPE_PT_ADD80
7107 | OPTS_TYPE_PT_ADDBITS15;
7108 kern_type = KERN_TYPE_SHA1;
7109 dgst_size = DGST_SIZE_4_5;
7110 parse_func = sha1_parse_hash;
7111 sort_by_digest = sort_by_digest_4_5;
7112 opti_type = OPTI_TYPE_ZERO_BYTE
7113 | OPTI_TYPE_PRECOMPUTE_INIT
7114 | OPTI_TYPE_PRECOMPUTE_MERKLE
7115 | OPTI_TYPE_EARLY_SKIP
7116 | OPTI_TYPE_NOT_ITERATED
7117 | OPTI_TYPE_NOT_SALTED
7118 | OPTI_TYPE_RAW_HASH;
7119 dgst_pos0 = 3;
7120 dgst_pos1 = 4;
7121 dgst_pos2 = 2;
7122 dgst_pos3 = 1;
7123 break;
7124
7125 case 101: hash_type = HASH_TYPE_SHA1;
7126 salt_type = SALT_TYPE_NONE;
7127 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7128 opts_type = OPTS_TYPE_PT_GENERATE_BE
7129 | OPTS_TYPE_PT_ADD80
7130 | OPTS_TYPE_PT_ADDBITS15;
7131 kern_type = KERN_TYPE_SHA1;
7132 dgst_size = DGST_SIZE_4_5;
7133 parse_func = sha1b64_parse_hash;
7134 sort_by_digest = sort_by_digest_4_5;
7135 opti_type = OPTI_TYPE_ZERO_BYTE
7136 | OPTI_TYPE_PRECOMPUTE_INIT
7137 | OPTI_TYPE_PRECOMPUTE_MERKLE
7138 | OPTI_TYPE_EARLY_SKIP
7139 | OPTI_TYPE_NOT_ITERATED
7140 | OPTI_TYPE_NOT_SALTED
7141 | OPTI_TYPE_RAW_HASH;
7142 dgst_pos0 = 3;
7143 dgst_pos1 = 4;
7144 dgst_pos2 = 2;
7145 dgst_pos3 = 1;
7146 break;
7147
7148 case 110: hash_type = HASH_TYPE_SHA1;
7149 salt_type = SALT_TYPE_INTERN;
7150 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7151 opts_type = OPTS_TYPE_PT_GENERATE_BE
7152 | OPTS_TYPE_ST_ADD80
7153 | OPTS_TYPE_ST_ADDBITS15;
7154 kern_type = KERN_TYPE_SHA1_PWSLT;
7155 dgst_size = DGST_SIZE_4_5;
7156 parse_func = sha1s_parse_hash;
7157 sort_by_digest = sort_by_digest_4_5;
7158 opti_type = OPTI_TYPE_ZERO_BYTE
7159 | OPTI_TYPE_PRECOMPUTE_INIT
7160 | OPTI_TYPE_PRECOMPUTE_MERKLE
7161 | OPTI_TYPE_EARLY_SKIP
7162 | OPTI_TYPE_NOT_ITERATED
7163 | OPTI_TYPE_APPENDED_SALT
7164 | OPTI_TYPE_RAW_HASH;
7165 dgst_pos0 = 3;
7166 dgst_pos1 = 4;
7167 dgst_pos2 = 2;
7168 dgst_pos3 = 1;
7169 break;
7170
7171 case 111: hash_type = HASH_TYPE_SHA1;
7172 salt_type = SALT_TYPE_EMBEDDED;
7173 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7174 opts_type = OPTS_TYPE_PT_GENERATE_BE
7175 | OPTS_TYPE_ST_ADD80
7176 | OPTS_TYPE_ST_ADDBITS15;
7177 kern_type = KERN_TYPE_SHA1_PWSLT;
7178 dgst_size = DGST_SIZE_4_5;
7179 parse_func = sha1b64s_parse_hash;
7180 sort_by_digest = sort_by_digest_4_5;
7181 opti_type = OPTI_TYPE_ZERO_BYTE
7182 | OPTI_TYPE_PRECOMPUTE_INIT
7183 | OPTI_TYPE_PRECOMPUTE_MERKLE
7184 | OPTI_TYPE_EARLY_SKIP
7185 | OPTI_TYPE_NOT_ITERATED
7186 | OPTI_TYPE_APPENDED_SALT
7187 | OPTI_TYPE_RAW_HASH;
7188 dgst_pos0 = 3;
7189 dgst_pos1 = 4;
7190 dgst_pos2 = 2;
7191 dgst_pos3 = 1;
7192 break;
7193
7194 case 112: hash_type = HASH_TYPE_SHA1;
7195 salt_type = SALT_TYPE_INTERN;
7196 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7197 opts_type = OPTS_TYPE_PT_GENERATE_BE
7198 | OPTS_TYPE_ST_ADD80
7199 | OPTS_TYPE_ST_ADDBITS15
7200 | OPTS_TYPE_ST_HEX;
7201 kern_type = KERN_TYPE_SHA1_PWSLT;
7202 dgst_size = DGST_SIZE_4_5;
7203 parse_func = oracles_parse_hash;
7204 sort_by_digest = sort_by_digest_4_5;
7205 opti_type = OPTI_TYPE_ZERO_BYTE
7206 | OPTI_TYPE_PRECOMPUTE_INIT
7207 | OPTI_TYPE_PRECOMPUTE_MERKLE
7208 | OPTI_TYPE_EARLY_SKIP
7209 | OPTI_TYPE_NOT_ITERATED
7210 | OPTI_TYPE_APPENDED_SALT
7211 | OPTI_TYPE_RAW_HASH;
7212 dgst_pos0 = 3;
7213 dgst_pos1 = 4;
7214 dgst_pos2 = 2;
7215 dgst_pos3 = 1;
7216 break;
7217
7218 case 120: hash_type = HASH_TYPE_SHA1;
7219 salt_type = SALT_TYPE_INTERN;
7220 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7221 opts_type = OPTS_TYPE_PT_GENERATE_BE
7222 | OPTS_TYPE_PT_ADD80
7223 | OPTS_TYPE_PT_ADDBITS15;
7224 kern_type = KERN_TYPE_SHA1_SLTPW;
7225 dgst_size = DGST_SIZE_4_5;
7226 parse_func = sha1s_parse_hash;
7227 sort_by_digest = sort_by_digest_4_5;
7228 opti_type = OPTI_TYPE_ZERO_BYTE
7229 | OPTI_TYPE_PRECOMPUTE_INIT
7230 | OPTI_TYPE_PRECOMPUTE_MERKLE
7231 | OPTI_TYPE_EARLY_SKIP
7232 | OPTI_TYPE_NOT_ITERATED
7233 | OPTI_TYPE_PREPENDED_SALT
7234 | OPTI_TYPE_RAW_HASH;
7235 dgst_pos0 = 3;
7236 dgst_pos1 = 4;
7237 dgst_pos2 = 2;
7238 dgst_pos3 = 1;
7239 break;
7240
7241 case 121: hash_type = HASH_TYPE_SHA1;
7242 salt_type = SALT_TYPE_INTERN;
7243 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7244 opts_type = OPTS_TYPE_PT_GENERATE_BE
7245 | OPTS_TYPE_PT_ADD80
7246 | OPTS_TYPE_PT_ADDBITS15
7247 | OPTS_TYPE_ST_LOWER;
7248 kern_type = KERN_TYPE_SHA1_SLTPW;
7249 dgst_size = DGST_SIZE_4_5;
7250 parse_func = smf_parse_hash;
7251 sort_by_digest = sort_by_digest_4_5;
7252 opti_type = OPTI_TYPE_ZERO_BYTE
7253 | OPTI_TYPE_PRECOMPUTE_INIT
7254 | OPTI_TYPE_PRECOMPUTE_MERKLE
7255 | OPTI_TYPE_EARLY_SKIP
7256 | OPTI_TYPE_NOT_ITERATED
7257 | OPTI_TYPE_PREPENDED_SALT
7258 | OPTI_TYPE_RAW_HASH;
7259 dgst_pos0 = 3;
7260 dgst_pos1 = 4;
7261 dgst_pos2 = 2;
7262 dgst_pos3 = 1;
7263 break;
7264
7265 case 122: hash_type = HASH_TYPE_SHA1;
7266 salt_type = SALT_TYPE_EMBEDDED;
7267 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7268 opts_type = OPTS_TYPE_PT_GENERATE_BE
7269 | OPTS_TYPE_PT_ADD80
7270 | OPTS_TYPE_PT_ADDBITS15
7271 | OPTS_TYPE_ST_HEX;
7272 kern_type = KERN_TYPE_SHA1_SLTPW;
7273 dgst_size = DGST_SIZE_4_5;
7274 parse_func = osx1_parse_hash;
7275 sort_by_digest = sort_by_digest_4_5;
7276 opti_type = OPTI_TYPE_ZERO_BYTE
7277 | OPTI_TYPE_PRECOMPUTE_INIT
7278 | OPTI_TYPE_PRECOMPUTE_MERKLE
7279 | OPTI_TYPE_EARLY_SKIP
7280 | OPTI_TYPE_NOT_ITERATED
7281 | OPTI_TYPE_PREPENDED_SALT
7282 | OPTI_TYPE_RAW_HASH;
7283 dgst_pos0 = 3;
7284 dgst_pos1 = 4;
7285 dgst_pos2 = 2;
7286 dgst_pos3 = 1;
7287 break;
7288
7289 case 124: hash_type = HASH_TYPE_SHA1;
7290 salt_type = SALT_TYPE_EMBEDDED;
7291 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7292 opts_type = OPTS_TYPE_PT_GENERATE_BE
7293 | OPTS_TYPE_PT_ADD80
7294 | OPTS_TYPE_PT_ADDBITS15;
7295 kern_type = KERN_TYPE_SHA1_SLTPW;
7296 dgst_size = DGST_SIZE_4_5;
7297 parse_func = djangosha1_parse_hash;
7298 sort_by_digest = sort_by_digest_4_5;
7299 opti_type = OPTI_TYPE_ZERO_BYTE
7300 | OPTI_TYPE_PRECOMPUTE_INIT
7301 | OPTI_TYPE_PRECOMPUTE_MERKLE
7302 | OPTI_TYPE_EARLY_SKIP
7303 | OPTI_TYPE_NOT_ITERATED
7304 | OPTI_TYPE_PREPENDED_SALT
7305 | OPTI_TYPE_RAW_HASH;
7306 dgst_pos0 = 3;
7307 dgst_pos1 = 4;
7308 dgst_pos2 = 2;
7309 dgst_pos3 = 1;
7310 break;
7311
7312 case 130: hash_type = HASH_TYPE_SHA1;
7313 salt_type = SALT_TYPE_INTERN;
7314 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7315 opts_type = OPTS_TYPE_PT_GENERATE_BE
7316 | OPTS_TYPE_PT_UNICODE
7317 | OPTS_TYPE_ST_ADD80
7318 | OPTS_TYPE_ST_ADDBITS15;
7319 kern_type = KERN_TYPE_SHA1_PWUSLT;
7320 dgst_size = DGST_SIZE_4_5;
7321 parse_func = sha1s_parse_hash;
7322 sort_by_digest = sort_by_digest_4_5;
7323 opti_type = OPTI_TYPE_ZERO_BYTE
7324 | OPTI_TYPE_PRECOMPUTE_INIT
7325 | OPTI_TYPE_PRECOMPUTE_MERKLE
7326 | OPTI_TYPE_EARLY_SKIP
7327 | OPTI_TYPE_NOT_ITERATED
7328 | OPTI_TYPE_APPENDED_SALT
7329 | OPTI_TYPE_RAW_HASH;
7330 dgst_pos0 = 3;
7331 dgst_pos1 = 4;
7332 dgst_pos2 = 2;
7333 dgst_pos3 = 1;
7334 break;
7335
7336 case 131: hash_type = HASH_TYPE_SHA1;
7337 salt_type = SALT_TYPE_EMBEDDED;
7338 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7339 opts_type = OPTS_TYPE_PT_GENERATE_BE
7340 | OPTS_TYPE_PT_UNICODE
7341 | OPTS_TYPE_PT_UPPER
7342 | OPTS_TYPE_ST_ADD80
7343 | OPTS_TYPE_ST_ADDBITS15
7344 | OPTS_TYPE_ST_HEX;
7345 kern_type = KERN_TYPE_SHA1_PWUSLT;
7346 dgst_size = DGST_SIZE_4_5;
7347 parse_func = mssql2000_parse_hash;
7348 sort_by_digest = sort_by_digest_4_5;
7349 opti_type = OPTI_TYPE_ZERO_BYTE
7350 | OPTI_TYPE_PRECOMPUTE_INIT
7351 | OPTI_TYPE_PRECOMPUTE_MERKLE
7352 | OPTI_TYPE_EARLY_SKIP
7353 | OPTI_TYPE_NOT_ITERATED
7354 | OPTI_TYPE_APPENDED_SALT
7355 | OPTI_TYPE_RAW_HASH;
7356 dgst_pos0 = 3;
7357 dgst_pos1 = 4;
7358 dgst_pos2 = 2;
7359 dgst_pos3 = 1;
7360 break;
7361
7362 case 132: hash_type = HASH_TYPE_SHA1;
7363 salt_type = SALT_TYPE_EMBEDDED;
7364 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7365 opts_type = OPTS_TYPE_PT_GENERATE_BE
7366 | OPTS_TYPE_PT_UNICODE
7367 | OPTS_TYPE_ST_ADD80
7368 | OPTS_TYPE_ST_ADDBITS15
7369 | OPTS_TYPE_ST_HEX;
7370 kern_type = KERN_TYPE_SHA1_PWUSLT;
7371 dgst_size = DGST_SIZE_4_5;
7372 parse_func = mssql2005_parse_hash;
7373 sort_by_digest = sort_by_digest_4_5;
7374 opti_type = OPTI_TYPE_ZERO_BYTE
7375 | OPTI_TYPE_PRECOMPUTE_INIT
7376 | OPTI_TYPE_PRECOMPUTE_MERKLE
7377 | OPTI_TYPE_EARLY_SKIP
7378 | OPTI_TYPE_NOT_ITERATED
7379 | OPTI_TYPE_APPENDED_SALT
7380 | OPTI_TYPE_RAW_HASH;
7381 dgst_pos0 = 3;
7382 dgst_pos1 = 4;
7383 dgst_pos2 = 2;
7384 dgst_pos3 = 1;
7385 break;
7386
7387 case 133: hash_type = HASH_TYPE_SHA1;
7388 salt_type = SALT_TYPE_EMBEDDED;
7389 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7390 opts_type = OPTS_TYPE_PT_GENERATE_BE
7391 | OPTS_TYPE_PT_UNICODE
7392 | OPTS_TYPE_ST_ADD80
7393 | OPTS_TYPE_ST_ADDBITS15;
7394 kern_type = KERN_TYPE_SHA1_PWUSLT;
7395 dgst_size = DGST_SIZE_4_5;
7396 parse_func = peoplesoft_parse_hash;
7397 sort_by_digest = sort_by_digest_4_5;
7398 opti_type = OPTI_TYPE_ZERO_BYTE
7399 | OPTI_TYPE_PRECOMPUTE_INIT
7400 | OPTI_TYPE_PRECOMPUTE_MERKLE
7401 | OPTI_TYPE_EARLY_SKIP
7402 | OPTI_TYPE_NOT_ITERATED
7403 | OPTI_TYPE_APPENDED_SALT
7404 | OPTI_TYPE_RAW_HASH;
7405 dgst_pos0 = 3;
7406 dgst_pos1 = 4;
7407 dgst_pos2 = 2;
7408 dgst_pos3 = 1;
7409 break;
7410
7411 case 140: hash_type = HASH_TYPE_SHA1;
7412 salt_type = SALT_TYPE_INTERN;
7413 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7414 opts_type = OPTS_TYPE_PT_GENERATE_BE
7415 | OPTS_TYPE_PT_ADD80
7416 | OPTS_TYPE_PT_ADDBITS15
7417 | OPTS_TYPE_PT_UNICODE;
7418 kern_type = KERN_TYPE_SHA1_SLTPWU;
7419 dgst_size = DGST_SIZE_4_5;
7420 parse_func = sha1s_parse_hash;
7421 sort_by_digest = sort_by_digest_4_5;
7422 opti_type = OPTI_TYPE_ZERO_BYTE
7423 | OPTI_TYPE_PRECOMPUTE_INIT
7424 | OPTI_TYPE_PRECOMPUTE_MERKLE
7425 | OPTI_TYPE_EARLY_SKIP
7426 | OPTI_TYPE_NOT_ITERATED
7427 | OPTI_TYPE_PREPENDED_SALT
7428 | OPTI_TYPE_RAW_HASH;
7429 dgst_pos0 = 3;
7430 dgst_pos1 = 4;
7431 dgst_pos2 = 2;
7432 dgst_pos3 = 1;
7433 break;
7434
7435 case 141: hash_type = HASH_TYPE_SHA1;
7436 salt_type = SALT_TYPE_EMBEDDED;
7437 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7438 opts_type = OPTS_TYPE_PT_GENERATE_BE
7439 | OPTS_TYPE_PT_ADD80
7440 | OPTS_TYPE_PT_ADDBITS15
7441 | OPTS_TYPE_PT_UNICODE
7442 | OPTS_TYPE_ST_BASE64;
7443 kern_type = KERN_TYPE_SHA1_SLTPWU;
7444 dgst_size = DGST_SIZE_4_5;
7445 parse_func = episerver_parse_hash;
7446 sort_by_digest = sort_by_digest_4_5;
7447 opti_type = OPTI_TYPE_ZERO_BYTE
7448 | OPTI_TYPE_PRECOMPUTE_INIT
7449 | OPTI_TYPE_PRECOMPUTE_MERKLE
7450 | OPTI_TYPE_EARLY_SKIP
7451 | OPTI_TYPE_NOT_ITERATED
7452 | OPTI_TYPE_PREPENDED_SALT
7453 | OPTI_TYPE_RAW_HASH;
7454 dgst_pos0 = 3;
7455 dgst_pos1 = 4;
7456 dgst_pos2 = 2;
7457 dgst_pos3 = 1;
7458 break;
7459
7460 case 150: hash_type = HASH_TYPE_SHA1;
7461 salt_type = SALT_TYPE_INTERN;
7462 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7463 opts_type = OPTS_TYPE_PT_GENERATE_BE
7464 | OPTS_TYPE_ST_ADD80
7465 | OPTS_TYPE_ST_ADDBITS15;
7466 kern_type = KERN_TYPE_HMACSHA1_PW;
7467 dgst_size = DGST_SIZE_4_5;
7468 parse_func = hmacsha1_parse_hash;
7469 sort_by_digest = sort_by_digest_4_5;
7470 opti_type = OPTI_TYPE_ZERO_BYTE
7471 | OPTI_TYPE_NOT_ITERATED;
7472 dgst_pos0 = 3;
7473 dgst_pos1 = 4;
7474 dgst_pos2 = 2;
7475 dgst_pos3 = 1;
7476 break;
7477
7478 case 160: hash_type = HASH_TYPE_SHA1;
7479 salt_type = SALT_TYPE_INTERN;
7480 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7481 opts_type = OPTS_TYPE_PT_GENERATE_BE
7482 | OPTS_TYPE_PT_ADD80
7483 | OPTS_TYPE_PT_ADDBITS15;
7484 kern_type = KERN_TYPE_HMACSHA1_SLT;
7485 dgst_size = DGST_SIZE_4_5;
7486 parse_func = hmacsha1_parse_hash;
7487 sort_by_digest = sort_by_digest_4_5;
7488 opti_type = OPTI_TYPE_ZERO_BYTE
7489 | OPTI_TYPE_NOT_ITERATED;
7490 dgst_pos0 = 3;
7491 dgst_pos1 = 4;
7492 dgst_pos2 = 2;
7493 dgst_pos3 = 1;
7494 break;
7495
7496 case 190: hash_type = HASH_TYPE_SHA1;
7497 salt_type = SALT_TYPE_NONE;
7498 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7499 opts_type = OPTS_TYPE_PT_GENERATE_BE
7500 | OPTS_TYPE_PT_ADD80
7501 | OPTS_TYPE_PT_ADDBITS15;
7502 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7503 dgst_size = DGST_SIZE_4_5;
7504 parse_func = sha1linkedin_parse_hash;
7505 sort_by_digest = sort_by_digest_4_5;
7506 opti_type = OPTI_TYPE_ZERO_BYTE
7507 | OPTI_TYPE_PRECOMPUTE_INIT
7508 | OPTI_TYPE_EARLY_SKIP
7509 | OPTI_TYPE_NOT_ITERATED
7510 | OPTI_TYPE_NOT_SALTED;
7511 dgst_pos0 = 0;
7512 dgst_pos1 = 4;
7513 dgst_pos2 = 3;
7514 dgst_pos3 = 2;
7515 break;
7516
7517 case 200: hash_type = HASH_TYPE_MYSQL;
7518 salt_type = SALT_TYPE_NONE;
7519 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7520 opts_type = 0;
7521 kern_type = KERN_TYPE_MYSQL;
7522 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7523 parse_func = mysql323_parse_hash;
7524 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7525 opti_type = OPTI_TYPE_ZERO_BYTE;
7526 dgst_pos0 = 0;
7527 dgst_pos1 = 1;
7528 dgst_pos2 = 2;
7529 dgst_pos3 = 3;
7530 break;
7531
7532 case 300: hash_type = HASH_TYPE_SHA1;
7533 salt_type = SALT_TYPE_NONE;
7534 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7535 opts_type = OPTS_TYPE_PT_GENERATE_BE
7536 | OPTS_TYPE_PT_ADD80
7537 | OPTS_TYPE_PT_ADDBITS15;
7538 kern_type = KERN_TYPE_MYSQL41;
7539 dgst_size = DGST_SIZE_4_5;
7540 parse_func = sha1_parse_hash;
7541 sort_by_digest = sort_by_digest_4_5;
7542 opti_type = OPTI_TYPE_ZERO_BYTE
7543 | OPTI_TYPE_PRECOMPUTE_INIT
7544 | OPTI_TYPE_PRECOMPUTE_MERKLE
7545 | OPTI_TYPE_EARLY_SKIP
7546 | OPTI_TYPE_NOT_ITERATED
7547 | OPTI_TYPE_NOT_SALTED;
7548 dgst_pos0 = 3;
7549 dgst_pos1 = 4;
7550 dgst_pos2 = 2;
7551 dgst_pos3 = 1;
7552 break;
7553
7554 case 400: hash_type = HASH_TYPE_MD5;
7555 salt_type = SALT_TYPE_EMBEDDED;
7556 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7557 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7558 kern_type = KERN_TYPE_PHPASS;
7559 dgst_size = DGST_SIZE_4_4;
7560 parse_func = phpass_parse_hash;
7561 sort_by_digest = sort_by_digest_4_4;
7562 opti_type = OPTI_TYPE_ZERO_BYTE;
7563 dgst_pos0 = 0;
7564 dgst_pos1 = 1;
7565 dgst_pos2 = 2;
7566 dgst_pos3 = 3;
7567 break;
7568
7569 case 500: hash_type = HASH_TYPE_MD5;
7570 salt_type = SALT_TYPE_EMBEDDED;
7571 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7572 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7573 kern_type = KERN_TYPE_MD5CRYPT;
7574 dgst_size = DGST_SIZE_4_4;
7575 parse_func = md5crypt_parse_hash;
7576 sort_by_digest = sort_by_digest_4_4;
7577 opti_type = OPTI_TYPE_ZERO_BYTE;
7578 dgst_pos0 = 0;
7579 dgst_pos1 = 1;
7580 dgst_pos2 = 2;
7581 dgst_pos3 = 3;
7582 break;
7583
7584 case 501: hash_type = HASH_TYPE_MD5;
7585 salt_type = SALT_TYPE_EMBEDDED;
7586 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7587 opts_type = OPTS_TYPE_PT_GENERATE_LE
7588 | OPTS_TYPE_HASH_COPY;
7589 kern_type = KERN_TYPE_MD5CRYPT;
7590 dgst_size = DGST_SIZE_4_4;
7591 parse_func = juniper_parse_hash;
7592 sort_by_digest = sort_by_digest_4_4;
7593 opti_type = OPTI_TYPE_ZERO_BYTE;
7594 dgst_pos0 = 0;
7595 dgst_pos1 = 1;
7596 dgst_pos2 = 2;
7597 dgst_pos3 = 3;
7598 break;
7599
7600 case 900: hash_type = HASH_TYPE_MD4;
7601 salt_type = SALT_TYPE_NONE;
7602 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7603 opts_type = OPTS_TYPE_PT_GENERATE_LE
7604 | OPTS_TYPE_PT_ADD80
7605 | OPTS_TYPE_PT_ADDBITS14;
7606 kern_type = KERN_TYPE_MD4;
7607 dgst_size = DGST_SIZE_4_4;
7608 parse_func = md4_parse_hash;
7609 sort_by_digest = sort_by_digest_4_4;
7610 opti_type = OPTI_TYPE_ZERO_BYTE
7611 | OPTI_TYPE_PRECOMPUTE_INIT
7612 | OPTI_TYPE_PRECOMPUTE_MERKLE
7613 | OPTI_TYPE_MEET_IN_MIDDLE
7614 | OPTI_TYPE_EARLY_SKIP
7615 | OPTI_TYPE_NOT_ITERATED
7616 | OPTI_TYPE_NOT_SALTED
7617 | OPTI_TYPE_RAW_HASH;
7618 dgst_pos0 = 0;
7619 dgst_pos1 = 3;
7620 dgst_pos2 = 2;
7621 dgst_pos3 = 1;
7622 break;
7623
7624 case 1000: hash_type = HASH_TYPE_MD4;
7625 salt_type = SALT_TYPE_NONE;
7626 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7627 opts_type = OPTS_TYPE_PT_GENERATE_LE
7628 | OPTS_TYPE_PT_ADD80
7629 | OPTS_TYPE_PT_ADDBITS14
7630 | OPTS_TYPE_PT_UNICODE;
7631 kern_type = KERN_TYPE_MD4_PWU;
7632 dgst_size = DGST_SIZE_4_4;
7633 parse_func = md4_parse_hash;
7634 sort_by_digest = sort_by_digest_4_4;
7635 opti_type = OPTI_TYPE_ZERO_BYTE
7636 | OPTI_TYPE_PRECOMPUTE_INIT
7637 | OPTI_TYPE_PRECOMPUTE_MERKLE
7638 | OPTI_TYPE_MEET_IN_MIDDLE
7639 | OPTI_TYPE_EARLY_SKIP
7640 | OPTI_TYPE_NOT_ITERATED
7641 | OPTI_TYPE_NOT_SALTED
7642 | OPTI_TYPE_RAW_HASH;
7643 dgst_pos0 = 0;
7644 dgst_pos1 = 3;
7645 dgst_pos2 = 2;
7646 dgst_pos3 = 1;
7647 break;
7648
7649 case 1100: hash_type = HASH_TYPE_MD4;
7650 salt_type = SALT_TYPE_INTERN;
7651 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7652 opts_type = OPTS_TYPE_PT_GENERATE_LE
7653 | OPTS_TYPE_PT_ADD80
7654 | OPTS_TYPE_PT_ADDBITS14
7655 | OPTS_TYPE_PT_UNICODE
7656 | OPTS_TYPE_ST_ADD80
7657 | OPTS_TYPE_ST_UNICODE
7658 | OPTS_TYPE_ST_LOWER;
7659 kern_type = KERN_TYPE_MD44_PWUSLT;
7660 dgst_size = DGST_SIZE_4_4;
7661 parse_func = dcc_parse_hash;
7662 sort_by_digest = sort_by_digest_4_4;
7663 opti_type = OPTI_TYPE_ZERO_BYTE
7664 | OPTI_TYPE_PRECOMPUTE_INIT
7665 | OPTI_TYPE_PRECOMPUTE_MERKLE
7666 | OPTI_TYPE_EARLY_SKIP
7667 | OPTI_TYPE_NOT_ITERATED;
7668 dgst_pos0 = 0;
7669 dgst_pos1 = 3;
7670 dgst_pos2 = 2;
7671 dgst_pos3 = 1;
7672 break;
7673
7674 case 1400: hash_type = HASH_TYPE_SHA256;
7675 salt_type = SALT_TYPE_NONE;
7676 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7677 opts_type = OPTS_TYPE_PT_GENERATE_BE
7678 | OPTS_TYPE_PT_ADD80
7679 | OPTS_TYPE_PT_ADDBITS15;
7680 kern_type = KERN_TYPE_SHA256;
7681 dgst_size = DGST_SIZE_4_8;
7682 parse_func = sha256_parse_hash;
7683 sort_by_digest = sort_by_digest_4_8;
7684 opti_type = OPTI_TYPE_ZERO_BYTE
7685 | OPTI_TYPE_PRECOMPUTE_INIT
7686 | OPTI_TYPE_PRECOMPUTE_MERKLE
7687 | OPTI_TYPE_EARLY_SKIP
7688 | OPTI_TYPE_NOT_ITERATED
7689 | OPTI_TYPE_NOT_SALTED
7690 | OPTI_TYPE_RAW_HASH;
7691 dgst_pos0 = 3;
7692 dgst_pos1 = 7;
7693 dgst_pos2 = 2;
7694 dgst_pos3 = 6;
7695 break;
7696
7697 case 1410: hash_type = HASH_TYPE_SHA256;
7698 salt_type = SALT_TYPE_INTERN;
7699 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7700 opts_type = OPTS_TYPE_PT_GENERATE_BE
7701 | OPTS_TYPE_ST_ADD80
7702 | OPTS_TYPE_ST_ADDBITS15;
7703 kern_type = KERN_TYPE_SHA256_PWSLT;
7704 dgst_size = DGST_SIZE_4_8;
7705 parse_func = sha256s_parse_hash;
7706 sort_by_digest = sort_by_digest_4_8;
7707 opti_type = OPTI_TYPE_ZERO_BYTE
7708 | OPTI_TYPE_PRECOMPUTE_INIT
7709 | OPTI_TYPE_PRECOMPUTE_MERKLE
7710 | OPTI_TYPE_EARLY_SKIP
7711 | OPTI_TYPE_NOT_ITERATED
7712 | OPTI_TYPE_APPENDED_SALT
7713 | OPTI_TYPE_RAW_HASH;
7714 dgst_pos0 = 3;
7715 dgst_pos1 = 7;
7716 dgst_pos2 = 2;
7717 dgst_pos3 = 6;
7718 break;
7719
7720 case 1420: hash_type = HASH_TYPE_SHA256;
7721 salt_type = SALT_TYPE_INTERN;
7722 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7723 opts_type = OPTS_TYPE_PT_GENERATE_BE
7724 | OPTS_TYPE_PT_ADD80
7725 | OPTS_TYPE_PT_ADDBITS15;
7726 kern_type = KERN_TYPE_SHA256_SLTPW;
7727 dgst_size = DGST_SIZE_4_8;
7728 parse_func = sha256s_parse_hash;
7729 sort_by_digest = sort_by_digest_4_8;
7730 opti_type = OPTI_TYPE_ZERO_BYTE
7731 | OPTI_TYPE_PRECOMPUTE_INIT
7732 | OPTI_TYPE_PRECOMPUTE_MERKLE
7733 | OPTI_TYPE_EARLY_SKIP
7734 | OPTI_TYPE_NOT_ITERATED
7735 | OPTI_TYPE_PREPENDED_SALT
7736 | OPTI_TYPE_RAW_HASH;
7737 dgst_pos0 = 3;
7738 dgst_pos1 = 7;
7739 dgst_pos2 = 2;
7740 dgst_pos3 = 6;
7741 break;
7742
7743 case 1421: hash_type = HASH_TYPE_SHA256;
7744 salt_type = SALT_TYPE_EMBEDDED;
7745 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7746 opts_type = OPTS_TYPE_PT_GENERATE_BE
7747 | OPTS_TYPE_PT_ADD80
7748 | OPTS_TYPE_PT_ADDBITS15;
7749 kern_type = KERN_TYPE_SHA256_SLTPW;
7750 dgst_size = DGST_SIZE_4_8;
7751 parse_func = hmailserver_parse_hash;
7752 sort_by_digest = sort_by_digest_4_8;
7753 opti_type = OPTI_TYPE_ZERO_BYTE
7754 | OPTI_TYPE_PRECOMPUTE_INIT
7755 | OPTI_TYPE_PRECOMPUTE_MERKLE
7756 | OPTI_TYPE_EARLY_SKIP
7757 | OPTI_TYPE_NOT_ITERATED
7758 | OPTI_TYPE_PREPENDED_SALT
7759 | OPTI_TYPE_RAW_HASH;
7760 dgst_pos0 = 3;
7761 dgst_pos1 = 7;
7762 dgst_pos2 = 2;
7763 dgst_pos3 = 6;
7764 break;
7765
7766 case 1430: hash_type = HASH_TYPE_SHA256;
7767 salt_type = SALT_TYPE_INTERN;
7768 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7769 opts_type = OPTS_TYPE_PT_GENERATE_BE
7770 | OPTS_TYPE_PT_UNICODE
7771 | OPTS_TYPE_ST_ADD80
7772 | OPTS_TYPE_ST_ADDBITS15;
7773 kern_type = KERN_TYPE_SHA256_PWUSLT;
7774 dgst_size = DGST_SIZE_4_8;
7775 parse_func = sha256s_parse_hash;
7776 sort_by_digest = sort_by_digest_4_8;
7777 opti_type = OPTI_TYPE_ZERO_BYTE
7778 | OPTI_TYPE_PRECOMPUTE_INIT
7779 | OPTI_TYPE_PRECOMPUTE_MERKLE
7780 | OPTI_TYPE_EARLY_SKIP
7781 | OPTI_TYPE_NOT_ITERATED
7782 | OPTI_TYPE_APPENDED_SALT
7783 | OPTI_TYPE_RAW_HASH;
7784 dgst_pos0 = 3;
7785 dgst_pos1 = 7;
7786 dgst_pos2 = 2;
7787 dgst_pos3 = 6;
7788 break;
7789
7790 case 1440: hash_type = HASH_TYPE_SHA256;
7791 salt_type = SALT_TYPE_INTERN;
7792 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7793 opts_type = OPTS_TYPE_PT_GENERATE_BE
7794 | OPTS_TYPE_PT_ADD80
7795 | OPTS_TYPE_PT_ADDBITS15
7796 | OPTS_TYPE_PT_UNICODE;
7797 kern_type = KERN_TYPE_SHA256_SLTPWU;
7798 dgst_size = DGST_SIZE_4_8;
7799 parse_func = sha256s_parse_hash;
7800 sort_by_digest = sort_by_digest_4_8;
7801 opti_type = OPTI_TYPE_ZERO_BYTE
7802 | OPTI_TYPE_PRECOMPUTE_INIT
7803 | OPTI_TYPE_PRECOMPUTE_MERKLE
7804 | OPTI_TYPE_EARLY_SKIP
7805 | OPTI_TYPE_NOT_ITERATED
7806 | OPTI_TYPE_PREPENDED_SALT
7807 | OPTI_TYPE_RAW_HASH;
7808 dgst_pos0 = 3;
7809 dgst_pos1 = 7;
7810 dgst_pos2 = 2;
7811 dgst_pos3 = 6;
7812 break;
7813
7814 case 1441: hash_type = HASH_TYPE_SHA256;
7815 salt_type = SALT_TYPE_EMBEDDED;
7816 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7817 opts_type = OPTS_TYPE_PT_GENERATE_BE
7818 | OPTS_TYPE_PT_ADD80
7819 | OPTS_TYPE_PT_ADDBITS15
7820 | OPTS_TYPE_PT_UNICODE
7821 | OPTS_TYPE_ST_BASE64;
7822 kern_type = KERN_TYPE_SHA256_SLTPWU;
7823 dgst_size = DGST_SIZE_4_8;
7824 parse_func = episerver4_parse_hash;
7825 sort_by_digest = sort_by_digest_4_8;
7826 opti_type = OPTI_TYPE_ZERO_BYTE
7827 | OPTI_TYPE_PRECOMPUTE_INIT
7828 | OPTI_TYPE_PRECOMPUTE_MERKLE
7829 | OPTI_TYPE_EARLY_SKIP
7830 | OPTI_TYPE_NOT_ITERATED
7831 | OPTI_TYPE_PREPENDED_SALT
7832 | OPTI_TYPE_RAW_HASH;
7833 dgst_pos0 = 3;
7834 dgst_pos1 = 7;
7835 dgst_pos2 = 2;
7836 dgst_pos3 = 6;
7837 break;
7838
7839 case 1450: hash_type = HASH_TYPE_SHA256;
7840 salt_type = SALT_TYPE_INTERN;
7841 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7842 opts_type = OPTS_TYPE_PT_GENERATE_BE
7843 | OPTS_TYPE_ST_ADD80;
7844 kern_type = KERN_TYPE_HMACSHA256_PW;
7845 dgst_size = DGST_SIZE_4_8;
7846 parse_func = hmacsha256_parse_hash;
7847 sort_by_digest = sort_by_digest_4_8;
7848 opti_type = OPTI_TYPE_ZERO_BYTE
7849 | OPTI_TYPE_NOT_ITERATED;
7850 dgst_pos0 = 3;
7851 dgst_pos1 = 7;
7852 dgst_pos2 = 2;
7853 dgst_pos3 = 6;
7854 break;
7855
7856 case 1460: hash_type = HASH_TYPE_SHA256;
7857 salt_type = SALT_TYPE_INTERN;
7858 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7859 opts_type = OPTS_TYPE_PT_GENERATE_BE
7860 | OPTS_TYPE_PT_ADD80
7861 | OPTS_TYPE_PT_ADDBITS15;
7862 kern_type = KERN_TYPE_HMACSHA256_SLT;
7863 dgst_size = DGST_SIZE_4_8;
7864 parse_func = hmacsha256_parse_hash;
7865 sort_by_digest = sort_by_digest_4_8;
7866 opti_type = OPTI_TYPE_ZERO_BYTE
7867 | OPTI_TYPE_NOT_ITERATED;
7868 dgst_pos0 = 3;
7869 dgst_pos1 = 7;
7870 dgst_pos2 = 2;
7871 dgst_pos3 = 6;
7872 break;
7873
7874 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7875 salt_type = SALT_TYPE_EMBEDDED;
7876 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7877 opts_type = OPTS_TYPE_PT_GENERATE_LE
7878 | OPTS_TYPE_PT_BITSLICE;
7879 kern_type = KERN_TYPE_DESCRYPT;
7880 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7881 parse_func = descrypt_parse_hash;
7882 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7883 opti_type = OPTI_TYPE_ZERO_BYTE
7884 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7885 dgst_pos0 = 0;
7886 dgst_pos1 = 1;
7887 dgst_pos2 = 2;
7888 dgst_pos3 = 3;
7889 break;
7890
7891 case 1600: hash_type = HASH_TYPE_MD5;
7892 salt_type = SALT_TYPE_EMBEDDED;
7893 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7894 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7895 kern_type = KERN_TYPE_APR1CRYPT;
7896 dgst_size = DGST_SIZE_4_4;
7897 parse_func = md5apr1_parse_hash;
7898 sort_by_digest = sort_by_digest_4_4;
7899 opti_type = OPTI_TYPE_ZERO_BYTE;
7900 dgst_pos0 = 0;
7901 dgst_pos1 = 1;
7902 dgst_pos2 = 2;
7903 dgst_pos3 = 3;
7904 break;
7905
7906 case 1700: hash_type = HASH_TYPE_SHA512;
7907 salt_type = SALT_TYPE_NONE;
7908 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7909 opts_type = OPTS_TYPE_PT_GENERATE_BE
7910 | OPTS_TYPE_PT_ADD80
7911 | OPTS_TYPE_PT_ADDBITS15;
7912 kern_type = KERN_TYPE_SHA512;
7913 dgst_size = DGST_SIZE_8_8;
7914 parse_func = sha512_parse_hash;
7915 sort_by_digest = sort_by_digest_8_8;
7916 opti_type = OPTI_TYPE_ZERO_BYTE
7917 | OPTI_TYPE_PRECOMPUTE_INIT
7918 | OPTI_TYPE_PRECOMPUTE_MERKLE
7919 | OPTI_TYPE_EARLY_SKIP
7920 | OPTI_TYPE_NOT_ITERATED
7921 | OPTI_TYPE_NOT_SALTED
7922 | OPTI_TYPE_USES_BITS_64
7923 | OPTI_TYPE_RAW_HASH;
7924 dgst_pos0 = 14;
7925 dgst_pos1 = 15;
7926 dgst_pos2 = 6;
7927 dgst_pos3 = 7;
7928 break;
7929
7930 case 1710: hash_type = HASH_TYPE_SHA512;
7931 salt_type = SALT_TYPE_INTERN;
7932 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7933 opts_type = OPTS_TYPE_PT_GENERATE_BE
7934 | OPTS_TYPE_ST_ADD80
7935 | OPTS_TYPE_ST_ADDBITS15;
7936 kern_type = KERN_TYPE_SHA512_PWSLT;
7937 dgst_size = DGST_SIZE_8_8;
7938 parse_func = sha512s_parse_hash;
7939 sort_by_digest = sort_by_digest_8_8;
7940 opti_type = OPTI_TYPE_ZERO_BYTE
7941 | OPTI_TYPE_PRECOMPUTE_INIT
7942 | OPTI_TYPE_PRECOMPUTE_MERKLE
7943 | OPTI_TYPE_EARLY_SKIP
7944 | OPTI_TYPE_NOT_ITERATED
7945 | OPTI_TYPE_APPENDED_SALT
7946 | OPTI_TYPE_USES_BITS_64
7947 | OPTI_TYPE_RAW_HASH;
7948 dgst_pos0 = 14;
7949 dgst_pos1 = 15;
7950 dgst_pos2 = 6;
7951 dgst_pos3 = 7;
7952 break;
7953
7954 case 1711: hash_type = HASH_TYPE_SHA512;
7955 salt_type = SALT_TYPE_EMBEDDED;
7956 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7957 opts_type = OPTS_TYPE_PT_GENERATE_BE
7958 | OPTS_TYPE_ST_ADD80
7959 | OPTS_TYPE_ST_ADDBITS15;
7960 kern_type = KERN_TYPE_SHA512_PWSLT;
7961 dgst_size = DGST_SIZE_8_8;
7962 parse_func = sha512b64s_parse_hash;
7963 sort_by_digest = sort_by_digest_8_8;
7964 opti_type = OPTI_TYPE_ZERO_BYTE
7965 | OPTI_TYPE_PRECOMPUTE_INIT
7966 | OPTI_TYPE_PRECOMPUTE_MERKLE
7967 | OPTI_TYPE_EARLY_SKIP
7968 | OPTI_TYPE_NOT_ITERATED
7969 | OPTI_TYPE_APPENDED_SALT
7970 | OPTI_TYPE_USES_BITS_64
7971 | OPTI_TYPE_RAW_HASH;
7972 dgst_pos0 = 14;
7973 dgst_pos1 = 15;
7974 dgst_pos2 = 6;
7975 dgst_pos3 = 7;
7976 break;
7977
7978 case 1720: hash_type = HASH_TYPE_SHA512;
7979 salt_type = SALT_TYPE_INTERN;
7980 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7981 opts_type = OPTS_TYPE_PT_GENERATE_BE
7982 | OPTS_TYPE_PT_ADD80
7983 | OPTS_TYPE_PT_ADDBITS15;
7984 kern_type = KERN_TYPE_SHA512_SLTPW;
7985 dgst_size = DGST_SIZE_8_8;
7986 parse_func = sha512s_parse_hash;
7987 sort_by_digest = sort_by_digest_8_8;
7988 opti_type = OPTI_TYPE_ZERO_BYTE
7989 | OPTI_TYPE_PRECOMPUTE_INIT
7990 | OPTI_TYPE_PRECOMPUTE_MERKLE
7991 | OPTI_TYPE_EARLY_SKIP
7992 | OPTI_TYPE_NOT_ITERATED
7993 | OPTI_TYPE_PREPENDED_SALT
7994 | OPTI_TYPE_USES_BITS_64
7995 | OPTI_TYPE_RAW_HASH;
7996 dgst_pos0 = 14;
7997 dgst_pos1 = 15;
7998 dgst_pos2 = 6;
7999 dgst_pos3 = 7;
8000 break;
8001
8002 case 1722: hash_type = HASH_TYPE_SHA512;
8003 salt_type = SALT_TYPE_EMBEDDED;
8004 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8005 opts_type = OPTS_TYPE_PT_GENERATE_BE
8006 | OPTS_TYPE_PT_ADD80
8007 | OPTS_TYPE_PT_ADDBITS15
8008 | OPTS_TYPE_ST_HEX;
8009 kern_type = KERN_TYPE_SHA512_SLTPW;
8010 dgst_size = DGST_SIZE_8_8;
8011 parse_func = osx512_parse_hash;
8012 sort_by_digest = sort_by_digest_8_8;
8013 opti_type = OPTI_TYPE_ZERO_BYTE
8014 | OPTI_TYPE_PRECOMPUTE_INIT
8015 | OPTI_TYPE_PRECOMPUTE_MERKLE
8016 | OPTI_TYPE_EARLY_SKIP
8017 | OPTI_TYPE_NOT_ITERATED
8018 | OPTI_TYPE_PREPENDED_SALT
8019 | OPTI_TYPE_USES_BITS_64
8020 | OPTI_TYPE_RAW_HASH;
8021 dgst_pos0 = 14;
8022 dgst_pos1 = 15;
8023 dgst_pos2 = 6;
8024 dgst_pos3 = 7;
8025 break;
8026
8027 case 1730: hash_type = HASH_TYPE_SHA512;
8028 salt_type = SALT_TYPE_INTERN;
8029 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8030 opts_type = OPTS_TYPE_PT_GENERATE_BE
8031 | OPTS_TYPE_PT_UNICODE
8032 | OPTS_TYPE_ST_ADD80
8033 | OPTS_TYPE_ST_ADDBITS15;
8034 kern_type = KERN_TYPE_SHA512_PWSLTU;
8035 dgst_size = DGST_SIZE_8_8;
8036 parse_func = sha512s_parse_hash;
8037 sort_by_digest = sort_by_digest_8_8;
8038 opti_type = OPTI_TYPE_ZERO_BYTE
8039 | OPTI_TYPE_PRECOMPUTE_INIT
8040 | OPTI_TYPE_PRECOMPUTE_MERKLE
8041 | OPTI_TYPE_EARLY_SKIP
8042 | OPTI_TYPE_NOT_ITERATED
8043 | OPTI_TYPE_APPENDED_SALT
8044 | OPTI_TYPE_USES_BITS_64
8045 | OPTI_TYPE_RAW_HASH;
8046 dgst_pos0 = 14;
8047 dgst_pos1 = 15;
8048 dgst_pos2 = 6;
8049 dgst_pos3 = 7;
8050 break;
8051
8052 case 1731: hash_type = HASH_TYPE_SHA512;
8053 salt_type = SALT_TYPE_EMBEDDED;
8054 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8055 opts_type = OPTS_TYPE_PT_GENERATE_BE
8056 | OPTS_TYPE_PT_UNICODE
8057 | OPTS_TYPE_ST_ADD80
8058 | OPTS_TYPE_ST_ADDBITS15
8059 | OPTS_TYPE_ST_HEX;
8060 kern_type = KERN_TYPE_SHA512_PWSLTU;
8061 dgst_size = DGST_SIZE_8_8;
8062 parse_func = mssql2012_parse_hash;
8063 sort_by_digest = sort_by_digest_8_8;
8064 opti_type = OPTI_TYPE_ZERO_BYTE
8065 | OPTI_TYPE_PRECOMPUTE_INIT
8066 | OPTI_TYPE_PRECOMPUTE_MERKLE
8067 | OPTI_TYPE_EARLY_SKIP
8068 | OPTI_TYPE_NOT_ITERATED
8069 | OPTI_TYPE_APPENDED_SALT
8070 | OPTI_TYPE_USES_BITS_64
8071 | OPTI_TYPE_RAW_HASH;
8072 dgst_pos0 = 14;
8073 dgst_pos1 = 15;
8074 dgst_pos2 = 6;
8075 dgst_pos3 = 7;
8076 break;
8077
8078 case 1740: hash_type = HASH_TYPE_SHA512;
8079 salt_type = SALT_TYPE_INTERN;
8080 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8081 opts_type = OPTS_TYPE_PT_GENERATE_BE
8082 | OPTS_TYPE_PT_ADD80
8083 | OPTS_TYPE_PT_ADDBITS15
8084 | OPTS_TYPE_PT_UNICODE;
8085 kern_type = KERN_TYPE_SHA512_SLTPWU;
8086 dgst_size = DGST_SIZE_8_8;
8087 parse_func = sha512s_parse_hash;
8088 sort_by_digest = sort_by_digest_8_8;
8089 opti_type = OPTI_TYPE_ZERO_BYTE
8090 | OPTI_TYPE_PRECOMPUTE_INIT
8091 | OPTI_TYPE_PRECOMPUTE_MERKLE
8092 | OPTI_TYPE_EARLY_SKIP
8093 | OPTI_TYPE_NOT_ITERATED
8094 | OPTI_TYPE_PREPENDED_SALT
8095 | OPTI_TYPE_USES_BITS_64
8096 | OPTI_TYPE_RAW_HASH;
8097 dgst_pos0 = 14;
8098 dgst_pos1 = 15;
8099 dgst_pos2 = 6;
8100 dgst_pos3 = 7;
8101 break;
8102
8103 case 1750: hash_type = HASH_TYPE_SHA512;
8104 salt_type = SALT_TYPE_INTERN;
8105 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8106 opts_type = OPTS_TYPE_PT_GENERATE_BE
8107 | OPTS_TYPE_ST_ADD80;
8108 kern_type = KERN_TYPE_HMACSHA512_PW;
8109 dgst_size = DGST_SIZE_8_8;
8110 parse_func = hmacsha512_parse_hash;
8111 sort_by_digest = sort_by_digest_8_8;
8112 opti_type = OPTI_TYPE_ZERO_BYTE
8113 | OPTI_TYPE_USES_BITS_64
8114 | OPTI_TYPE_NOT_ITERATED;
8115 dgst_pos0 = 14;
8116 dgst_pos1 = 15;
8117 dgst_pos2 = 6;
8118 dgst_pos3 = 7;
8119 break;
8120
8121 case 1760: hash_type = HASH_TYPE_SHA512;
8122 salt_type = SALT_TYPE_INTERN;
8123 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8124 opts_type = OPTS_TYPE_PT_GENERATE_BE
8125 | OPTS_TYPE_PT_ADD80
8126 | OPTS_TYPE_PT_ADDBITS15;
8127 kern_type = KERN_TYPE_HMACSHA512_SLT;
8128 dgst_size = DGST_SIZE_8_8;
8129 parse_func = hmacsha512_parse_hash;
8130 sort_by_digest = sort_by_digest_8_8;
8131 opti_type = OPTI_TYPE_ZERO_BYTE
8132 | OPTI_TYPE_USES_BITS_64
8133 | OPTI_TYPE_NOT_ITERATED;
8134 dgst_pos0 = 14;
8135 dgst_pos1 = 15;
8136 dgst_pos2 = 6;
8137 dgst_pos3 = 7;
8138 break;
8139
8140 case 1800: hash_type = HASH_TYPE_SHA512;
8141 salt_type = SALT_TYPE_EMBEDDED;
8142 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8143 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8144 kern_type = KERN_TYPE_SHA512CRYPT;
8145 dgst_size = DGST_SIZE_8_8;
8146 parse_func = sha512crypt_parse_hash;
8147 sort_by_digest = sort_by_digest_8_8;
8148 opti_type = OPTI_TYPE_ZERO_BYTE
8149 | OPTI_TYPE_USES_BITS_64;
8150 dgst_pos0 = 0;
8151 dgst_pos1 = 1;
8152 dgst_pos2 = 2;
8153 dgst_pos3 = 3;
8154 break;
8155
8156 case 2100: hash_type = HASH_TYPE_DCC2;
8157 salt_type = SALT_TYPE_EMBEDDED;
8158 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8159 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8160 | OPTS_TYPE_ST_LOWER
8161 | OPTS_TYPE_ST_UNICODE;
8162 kern_type = KERN_TYPE_DCC2;
8163 dgst_size = DGST_SIZE_4_4;
8164 parse_func = dcc2_parse_hash;
8165 sort_by_digest = sort_by_digest_4_4;
8166 opti_type = OPTI_TYPE_ZERO_BYTE;
8167 dgst_pos0 = 0;
8168 dgst_pos1 = 1;
8169 dgst_pos2 = 2;
8170 dgst_pos3 = 3;
8171 break;
8172
8173 case 2400: hash_type = HASH_TYPE_MD5;
8174 salt_type = SALT_TYPE_NONE;
8175 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8176 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8177 kern_type = KERN_TYPE_MD5PIX;
8178 dgst_size = DGST_SIZE_4_4;
8179 parse_func = md5pix_parse_hash;
8180 sort_by_digest = sort_by_digest_4_4;
8181 opti_type = OPTI_TYPE_ZERO_BYTE
8182 | OPTI_TYPE_PRECOMPUTE_INIT
8183 | OPTI_TYPE_PRECOMPUTE_MERKLE
8184 | OPTI_TYPE_EARLY_SKIP
8185 | OPTI_TYPE_NOT_ITERATED
8186 | OPTI_TYPE_NOT_SALTED;
8187 dgst_pos0 = 0;
8188 dgst_pos1 = 3;
8189 dgst_pos2 = 2;
8190 dgst_pos3 = 1;
8191 break;
8192
8193 case 2410: hash_type = HASH_TYPE_MD5;
8194 salt_type = SALT_TYPE_INTERN;
8195 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8196 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8197 kern_type = KERN_TYPE_MD5ASA;
8198 dgst_size = DGST_SIZE_4_4;
8199 parse_func = md5asa_parse_hash;
8200 sort_by_digest = sort_by_digest_4_4;
8201 opti_type = OPTI_TYPE_ZERO_BYTE
8202 | OPTI_TYPE_PRECOMPUTE_INIT
8203 | OPTI_TYPE_PRECOMPUTE_MERKLE
8204 | OPTI_TYPE_EARLY_SKIP
8205 | OPTI_TYPE_NOT_ITERATED;
8206 dgst_pos0 = 0;
8207 dgst_pos1 = 3;
8208 dgst_pos2 = 2;
8209 dgst_pos3 = 1;
8210 break;
8211
8212 case 2500: hash_type = HASH_TYPE_WPA;
8213 salt_type = SALT_TYPE_EMBEDDED;
8214 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8215 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8216 kern_type = KERN_TYPE_WPA;
8217 dgst_size = DGST_SIZE_4_4;
8218 parse_func = wpa_parse_hash;
8219 sort_by_digest = sort_by_digest_4_4;
8220 opti_type = OPTI_TYPE_ZERO_BYTE;
8221 dgst_pos0 = 0;
8222 dgst_pos1 = 1;
8223 dgst_pos2 = 2;
8224 dgst_pos3 = 3;
8225 break;
8226
8227 case 2600: hash_type = HASH_TYPE_MD5;
8228 salt_type = SALT_TYPE_VIRTUAL;
8229 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8230 opts_type = OPTS_TYPE_PT_GENERATE_LE
8231 | OPTS_TYPE_PT_ADD80
8232 | OPTS_TYPE_PT_ADDBITS14
8233 | OPTS_TYPE_ST_ADD80;
8234 kern_type = KERN_TYPE_MD55_PWSLT1;
8235 dgst_size = DGST_SIZE_4_4;
8236 parse_func = md5md5_parse_hash;
8237 sort_by_digest = sort_by_digest_4_4;
8238 opti_type = OPTI_TYPE_ZERO_BYTE
8239 | OPTI_TYPE_PRECOMPUTE_INIT
8240 | OPTI_TYPE_PRECOMPUTE_MERKLE
8241 | OPTI_TYPE_EARLY_SKIP;
8242 dgst_pos0 = 0;
8243 dgst_pos1 = 3;
8244 dgst_pos2 = 2;
8245 dgst_pos3 = 1;
8246 break;
8247
8248 case 2611: hash_type = HASH_TYPE_MD5;
8249 salt_type = SALT_TYPE_INTERN;
8250 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8251 opts_type = OPTS_TYPE_PT_GENERATE_LE
8252 | OPTS_TYPE_PT_ADD80
8253 | OPTS_TYPE_PT_ADDBITS14
8254 | OPTS_TYPE_ST_ADD80;
8255 kern_type = KERN_TYPE_MD55_PWSLT1;
8256 dgst_size = DGST_SIZE_4_4;
8257 parse_func = vb3_parse_hash;
8258 sort_by_digest = sort_by_digest_4_4;
8259 opti_type = OPTI_TYPE_ZERO_BYTE
8260 | OPTI_TYPE_PRECOMPUTE_INIT
8261 | OPTI_TYPE_PRECOMPUTE_MERKLE
8262 | OPTI_TYPE_EARLY_SKIP;
8263 dgst_pos0 = 0;
8264 dgst_pos1 = 3;
8265 dgst_pos2 = 2;
8266 dgst_pos3 = 1;
8267 break;
8268
8269 case 2612: hash_type = HASH_TYPE_MD5;
8270 salt_type = SALT_TYPE_EMBEDDED;
8271 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8272 opts_type = OPTS_TYPE_PT_GENERATE_LE
8273 | OPTS_TYPE_PT_ADD80
8274 | OPTS_TYPE_PT_ADDBITS14
8275 | OPTS_TYPE_ST_ADD80
8276 | OPTS_TYPE_ST_HEX;
8277 kern_type = KERN_TYPE_MD55_PWSLT1;
8278 dgst_size = DGST_SIZE_4_4;
8279 parse_func = phps_parse_hash;
8280 sort_by_digest = sort_by_digest_4_4;
8281 opti_type = OPTI_TYPE_ZERO_BYTE
8282 | OPTI_TYPE_PRECOMPUTE_INIT
8283 | OPTI_TYPE_PRECOMPUTE_MERKLE
8284 | OPTI_TYPE_EARLY_SKIP;
8285 dgst_pos0 = 0;
8286 dgst_pos1 = 3;
8287 dgst_pos2 = 2;
8288 dgst_pos3 = 1;
8289 break;
8290
8291 case 2711: hash_type = HASH_TYPE_MD5;
8292 salt_type = SALT_TYPE_INTERN;
8293 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8294 opts_type = OPTS_TYPE_PT_GENERATE_LE
8295 | OPTS_TYPE_PT_ADD80
8296 | OPTS_TYPE_PT_ADDBITS14
8297 | OPTS_TYPE_ST_ADD80;
8298 kern_type = KERN_TYPE_MD55_PWSLT2;
8299 dgst_size = DGST_SIZE_4_4;
8300 parse_func = vb30_parse_hash;
8301 sort_by_digest = sort_by_digest_4_4;
8302 opti_type = OPTI_TYPE_ZERO_BYTE
8303 | OPTI_TYPE_PRECOMPUTE_INIT
8304 | OPTI_TYPE_EARLY_SKIP;
8305 dgst_pos0 = 0;
8306 dgst_pos1 = 3;
8307 dgst_pos2 = 2;
8308 dgst_pos3 = 1;
8309 break;
8310
8311 case 2811: hash_type = HASH_TYPE_MD5;
8312 salt_type = SALT_TYPE_INTERN;
8313 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8314 opts_type = OPTS_TYPE_PT_GENERATE_LE
8315 | OPTS_TYPE_PT_ADD80
8316 | OPTS_TYPE_PT_ADDBITS14;
8317 kern_type = KERN_TYPE_MD55_SLTPW;
8318 dgst_size = DGST_SIZE_4_4;
8319 parse_func = ipb2_parse_hash;
8320 sort_by_digest = sort_by_digest_4_4;
8321 opti_type = OPTI_TYPE_ZERO_BYTE
8322 | OPTI_TYPE_PRECOMPUTE_INIT
8323 | OPTI_TYPE_EARLY_SKIP;
8324 dgst_pos0 = 0;
8325 dgst_pos1 = 3;
8326 dgst_pos2 = 2;
8327 dgst_pos3 = 1;
8328 break;
8329
8330 case 3000: hash_type = HASH_TYPE_LM;
8331 salt_type = SALT_TYPE_NONE;
8332 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8333 opts_type = OPTS_TYPE_PT_GENERATE_LE
8334 | OPTS_TYPE_PT_UPPER
8335 | OPTS_TYPE_PT_BITSLICE;
8336 kern_type = KERN_TYPE_LM;
8337 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8338 parse_func = lm_parse_hash;
8339 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8340 opti_type = OPTI_TYPE_ZERO_BYTE
8341 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8342 dgst_pos0 = 0;
8343 dgst_pos1 = 1;
8344 dgst_pos2 = 2;
8345 dgst_pos3 = 3;
8346 break;
8347
8348 case 3100: hash_type = HASH_TYPE_ORACLEH;
8349 salt_type = SALT_TYPE_INTERN;
8350 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8351 opts_type = OPTS_TYPE_PT_GENERATE_LE
8352 | OPTS_TYPE_PT_UPPER
8353 | OPTS_TYPE_ST_UPPER;
8354 kern_type = KERN_TYPE_ORACLEH;
8355 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8356 parse_func = oracleh_parse_hash;
8357 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8358 opti_type = OPTI_TYPE_ZERO_BYTE;
8359 dgst_pos0 = 0;
8360 dgst_pos1 = 1;
8361 dgst_pos2 = 2;
8362 dgst_pos3 = 3;
8363 break;
8364
8365 case 3200: hash_type = HASH_TYPE_BCRYPT;
8366 salt_type = SALT_TYPE_EMBEDDED;
8367 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8368 opts_type = OPTS_TYPE_PT_GENERATE_LE
8369 | OPTS_TYPE_ST_GENERATE_LE;
8370 kern_type = KERN_TYPE_BCRYPT;
8371 dgst_size = DGST_SIZE_4_6;
8372 parse_func = bcrypt_parse_hash;
8373 sort_by_digest = sort_by_digest_4_6;
8374 opti_type = OPTI_TYPE_ZERO_BYTE;
8375 dgst_pos0 = 0;
8376 dgst_pos1 = 1;
8377 dgst_pos2 = 2;
8378 dgst_pos3 = 3;
8379 break;
8380
8381 case 3710: hash_type = HASH_TYPE_MD5;
8382 salt_type = SALT_TYPE_INTERN;
8383 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8384 opts_type = OPTS_TYPE_PT_GENERATE_LE
8385 | OPTS_TYPE_PT_ADD80
8386 | OPTS_TYPE_PT_ADDBITS14;
8387 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8388 dgst_size = DGST_SIZE_4_4;
8389 parse_func = md5s_parse_hash;
8390 sort_by_digest = sort_by_digest_4_4;
8391 opti_type = OPTI_TYPE_ZERO_BYTE
8392 | OPTI_TYPE_PRECOMPUTE_INIT
8393 | OPTI_TYPE_PRECOMPUTE_MERKLE
8394 | OPTI_TYPE_EARLY_SKIP;
8395 dgst_pos0 = 0;
8396 dgst_pos1 = 3;
8397 dgst_pos2 = 2;
8398 dgst_pos3 = 1;
8399 break;
8400
8401 case 3711: hash_type = HASH_TYPE_MD5;
8402 salt_type = SALT_TYPE_EMBEDDED;
8403 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8404 opts_type = OPTS_TYPE_PT_GENERATE_LE
8405 | OPTS_TYPE_PT_ADD80
8406 | OPTS_TYPE_PT_ADDBITS14;
8407 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8408 dgst_size = DGST_SIZE_4_4;
8409 parse_func = mediawiki_b_parse_hash;
8410 sort_by_digest = sort_by_digest_4_4;
8411 opti_type = OPTI_TYPE_ZERO_BYTE
8412 | OPTI_TYPE_PRECOMPUTE_INIT
8413 | OPTI_TYPE_PRECOMPUTE_MERKLE
8414 | OPTI_TYPE_EARLY_SKIP;
8415 dgst_pos0 = 0;
8416 dgst_pos1 = 3;
8417 dgst_pos2 = 2;
8418 dgst_pos3 = 1;
8419 break;
8420
8421 case 3800: hash_type = HASH_TYPE_MD5;
8422 salt_type = SALT_TYPE_INTERN;
8423 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8424 opts_type = OPTS_TYPE_PT_GENERATE_LE
8425 | OPTS_TYPE_ST_ADDBITS14;
8426 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8427 dgst_size = DGST_SIZE_4_4;
8428 parse_func = md5s_parse_hash;
8429 sort_by_digest = sort_by_digest_4_4;
8430 opti_type = OPTI_TYPE_ZERO_BYTE
8431 | OPTI_TYPE_PRECOMPUTE_INIT
8432 | OPTI_TYPE_PRECOMPUTE_MERKLE
8433 | OPTI_TYPE_EARLY_SKIP
8434 | OPTI_TYPE_NOT_ITERATED
8435 | OPTI_TYPE_RAW_HASH;
8436 dgst_pos0 = 0;
8437 dgst_pos1 = 3;
8438 dgst_pos2 = 2;
8439 dgst_pos3 = 1;
8440 break;
8441
8442 case 4300: hash_type = HASH_TYPE_MD5;
8443 salt_type = SALT_TYPE_VIRTUAL;
8444 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8445 opts_type = OPTS_TYPE_PT_GENERATE_LE
8446 | OPTS_TYPE_PT_ADD80
8447 | OPTS_TYPE_PT_ADDBITS14
8448 | OPTS_TYPE_ST_ADD80;
8449 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8450 dgst_size = DGST_SIZE_4_4;
8451 parse_func = md5md5_parse_hash;
8452 sort_by_digest = sort_by_digest_4_4;
8453 opti_type = OPTI_TYPE_ZERO_BYTE
8454 | OPTI_TYPE_PRECOMPUTE_INIT
8455 | OPTI_TYPE_PRECOMPUTE_MERKLE
8456 | OPTI_TYPE_EARLY_SKIP;
8457 dgst_pos0 = 0;
8458 dgst_pos1 = 3;
8459 dgst_pos2 = 2;
8460 dgst_pos3 = 1;
8461 break;
8462
8463
8464 case 4400: hash_type = HASH_TYPE_MD5;
8465 salt_type = SALT_TYPE_NONE;
8466 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8467 opts_type = OPTS_TYPE_PT_GENERATE_BE
8468 | OPTS_TYPE_PT_ADD80
8469 | OPTS_TYPE_PT_ADDBITS15;
8470 kern_type = KERN_TYPE_MD5_SHA1;
8471 dgst_size = DGST_SIZE_4_4;
8472 parse_func = md5_parse_hash;
8473 sort_by_digest = sort_by_digest_4_4;
8474 opti_type = OPTI_TYPE_ZERO_BYTE
8475 | OPTI_TYPE_PRECOMPUTE_INIT
8476 | OPTI_TYPE_PRECOMPUTE_MERKLE
8477 | OPTI_TYPE_EARLY_SKIP
8478 | OPTI_TYPE_NOT_ITERATED
8479 | OPTI_TYPE_NOT_SALTED
8480 | OPTI_TYPE_RAW_HASH;
8481 dgst_pos0 = 0;
8482 dgst_pos1 = 3;
8483 dgst_pos2 = 2;
8484 dgst_pos3 = 1;
8485 break;
8486
8487 case 4500: hash_type = HASH_TYPE_SHA1;
8488 salt_type = SALT_TYPE_NONE;
8489 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8490 opts_type = OPTS_TYPE_PT_GENERATE_BE
8491 | OPTS_TYPE_PT_ADD80
8492 | OPTS_TYPE_PT_ADDBITS15;
8493 kern_type = KERN_TYPE_SHA11;
8494 dgst_size = DGST_SIZE_4_5;
8495 parse_func = sha1_parse_hash;
8496 sort_by_digest = sort_by_digest_4_5;
8497 opti_type = OPTI_TYPE_ZERO_BYTE
8498 | OPTI_TYPE_PRECOMPUTE_INIT
8499 | OPTI_TYPE_PRECOMPUTE_MERKLE
8500 | OPTI_TYPE_EARLY_SKIP
8501 | OPTI_TYPE_NOT_SALTED;
8502 dgst_pos0 = 3;
8503 dgst_pos1 = 4;
8504 dgst_pos2 = 2;
8505 dgst_pos3 = 1;
8506 break;
8507
8508 case 4700: hash_type = HASH_TYPE_SHA1;
8509 salt_type = SALT_TYPE_NONE;
8510 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8511 opts_type = OPTS_TYPE_PT_GENERATE_LE
8512 | OPTS_TYPE_PT_ADD80
8513 | OPTS_TYPE_PT_ADDBITS14;
8514 kern_type = KERN_TYPE_SHA1_MD5;
8515 dgst_size = DGST_SIZE_4_5;
8516 parse_func = sha1_parse_hash;
8517 sort_by_digest = sort_by_digest_4_5;
8518 opti_type = OPTI_TYPE_ZERO_BYTE
8519 | OPTI_TYPE_PRECOMPUTE_INIT
8520 | OPTI_TYPE_PRECOMPUTE_MERKLE
8521 | OPTI_TYPE_EARLY_SKIP
8522 | OPTI_TYPE_NOT_ITERATED
8523 | OPTI_TYPE_NOT_SALTED
8524 | OPTI_TYPE_RAW_HASH;
8525 dgst_pos0 = 3;
8526 dgst_pos1 = 4;
8527 dgst_pos2 = 2;
8528 dgst_pos3 = 1;
8529 break;
8530
8531 case 4800: hash_type = HASH_TYPE_MD5;
8532 salt_type = SALT_TYPE_EMBEDDED;
8533 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8534 opts_type = OPTS_TYPE_PT_GENERATE_LE
8535 | OPTS_TYPE_PT_ADDBITS14;
8536 kern_type = KERN_TYPE_MD5_CHAP;
8537 dgst_size = DGST_SIZE_4_4;
8538 parse_func = chap_parse_hash;
8539 sort_by_digest = sort_by_digest_4_4;
8540 opti_type = OPTI_TYPE_ZERO_BYTE
8541 | OPTI_TYPE_PRECOMPUTE_INIT
8542 | OPTI_TYPE_PRECOMPUTE_MERKLE
8543 | OPTI_TYPE_MEET_IN_MIDDLE
8544 | OPTI_TYPE_EARLY_SKIP
8545 | OPTI_TYPE_NOT_ITERATED
8546 | OPTI_TYPE_RAW_HASH;
8547 dgst_pos0 = 0;
8548 dgst_pos1 = 3;
8549 dgst_pos2 = 2;
8550 dgst_pos3 = 1;
8551 break;
8552
8553 case 4900: hash_type = HASH_TYPE_SHA1;
8554 salt_type = SALT_TYPE_INTERN;
8555 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8556 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8557 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8558 dgst_size = DGST_SIZE_4_5;
8559 parse_func = sha1s_parse_hash;
8560 sort_by_digest = sort_by_digest_4_5;
8561 opti_type = OPTI_TYPE_ZERO_BYTE
8562 | OPTI_TYPE_PRECOMPUTE_INIT
8563 | OPTI_TYPE_PRECOMPUTE_MERKLE
8564 | OPTI_TYPE_EARLY_SKIP;
8565 dgst_pos0 = 3;
8566 dgst_pos1 = 4;
8567 dgst_pos2 = 2;
8568 dgst_pos3 = 1;
8569 break;
8570
8571 case 5000: hash_type = HASH_TYPE_KECCAK;
8572 salt_type = SALT_TYPE_EMBEDDED;
8573 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8574 opts_type = OPTS_TYPE_PT_GENERATE_LE
8575 | OPTS_TYPE_PT_ADD01;
8576 kern_type = KERN_TYPE_KECCAK;
8577 dgst_size = DGST_SIZE_8_25;
8578 parse_func = keccak_parse_hash;
8579 sort_by_digest = sort_by_digest_8_25;
8580 opti_type = OPTI_TYPE_ZERO_BYTE
8581 | OPTI_TYPE_USES_BITS_64
8582 | OPTI_TYPE_RAW_HASH;
8583 dgst_pos0 = 2;
8584 dgst_pos1 = 3;
8585 dgst_pos2 = 4;
8586 dgst_pos3 = 5;
8587 break;
8588
8589 case 5100: hash_type = HASH_TYPE_MD5H;
8590 salt_type = SALT_TYPE_NONE;
8591 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8592 opts_type = OPTS_TYPE_PT_GENERATE_LE
8593 | OPTS_TYPE_PT_ADD80
8594 | OPTS_TYPE_PT_ADDBITS14;
8595 kern_type = KERN_TYPE_MD5H;
8596 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8597 parse_func = md5half_parse_hash;
8598 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8599 opti_type = OPTI_TYPE_ZERO_BYTE
8600 | OPTI_TYPE_RAW_HASH;
8601 dgst_pos0 = 0;
8602 dgst_pos1 = 1;
8603 dgst_pos2 = 2;
8604 dgst_pos3 = 3;
8605 break;
8606
8607 case 5200: hash_type = HASH_TYPE_SHA256;
8608 salt_type = SALT_TYPE_EMBEDDED;
8609 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8610 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8611 kern_type = KERN_TYPE_PSAFE3;
8612 dgst_size = DGST_SIZE_4_8;
8613 parse_func = psafe3_parse_hash;
8614 sort_by_digest = sort_by_digest_4_8;
8615 opti_type = OPTI_TYPE_ZERO_BYTE;
8616 dgst_pos0 = 0;
8617 dgst_pos1 = 1;
8618 dgst_pos2 = 2;
8619 dgst_pos3 = 3;
8620 break;
8621
8622 case 5300: hash_type = HASH_TYPE_MD5;
8623 salt_type = SALT_TYPE_EMBEDDED;
8624 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8625 opts_type = OPTS_TYPE_PT_GENERATE_LE
8626 | OPTS_TYPE_ST_ADD80;
8627 kern_type = KERN_TYPE_IKEPSK_MD5;
8628 dgst_size = DGST_SIZE_4_4;
8629 parse_func = ikepsk_md5_parse_hash;
8630 sort_by_digest = sort_by_digest_4_4;
8631 opti_type = OPTI_TYPE_ZERO_BYTE;
8632 dgst_pos0 = 0;
8633 dgst_pos1 = 3;
8634 dgst_pos2 = 2;
8635 dgst_pos3 = 1;
8636 break;
8637
8638 case 5400: hash_type = HASH_TYPE_SHA1;
8639 salt_type = SALT_TYPE_EMBEDDED;
8640 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8641 opts_type = OPTS_TYPE_PT_GENERATE_BE
8642 | OPTS_TYPE_ST_ADD80;
8643 kern_type = KERN_TYPE_IKEPSK_SHA1;
8644 dgst_size = DGST_SIZE_4_5;
8645 parse_func = ikepsk_sha1_parse_hash;
8646 sort_by_digest = sort_by_digest_4_5;
8647 opti_type = OPTI_TYPE_ZERO_BYTE;
8648 dgst_pos0 = 3;
8649 dgst_pos1 = 4;
8650 dgst_pos2 = 2;
8651 dgst_pos3 = 1;
8652 break;
8653
8654 case 5500: hash_type = HASH_TYPE_NETNTLM;
8655 salt_type = SALT_TYPE_EMBEDDED;
8656 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8657 opts_type = OPTS_TYPE_PT_GENERATE_LE
8658 | OPTS_TYPE_PT_ADD80
8659 | OPTS_TYPE_PT_ADDBITS14
8660 | OPTS_TYPE_PT_UNICODE
8661 | OPTS_TYPE_ST_HEX;
8662 kern_type = KERN_TYPE_NETNTLMv1;
8663 dgst_size = DGST_SIZE_4_4;
8664 parse_func = netntlmv1_parse_hash;
8665 sort_by_digest = sort_by_digest_4_4;
8666 opti_type = OPTI_TYPE_ZERO_BYTE
8667 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8668 dgst_pos0 = 0;
8669 dgst_pos1 = 1;
8670 dgst_pos2 = 2;
8671 dgst_pos3 = 3;
8672 break;
8673
8674 case 5600: hash_type = HASH_TYPE_MD5;
8675 salt_type = SALT_TYPE_EMBEDDED;
8676 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8677 opts_type = OPTS_TYPE_PT_GENERATE_LE
8678 | OPTS_TYPE_PT_ADD80
8679 | OPTS_TYPE_PT_ADDBITS14
8680 | OPTS_TYPE_PT_UNICODE;
8681 kern_type = KERN_TYPE_NETNTLMv2;
8682 dgst_size = DGST_SIZE_4_4;
8683 parse_func = netntlmv2_parse_hash;
8684 sort_by_digest = sort_by_digest_4_4;
8685 opti_type = OPTI_TYPE_ZERO_BYTE;
8686 dgst_pos0 = 0;
8687 dgst_pos1 = 3;
8688 dgst_pos2 = 2;
8689 dgst_pos3 = 1;
8690 break;
8691
8692 case 5700: hash_type = HASH_TYPE_SHA256;
8693 salt_type = SALT_TYPE_NONE;
8694 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8695 opts_type = OPTS_TYPE_PT_GENERATE_BE
8696 | OPTS_TYPE_PT_ADD80
8697 | OPTS_TYPE_PT_ADDBITS15;
8698 kern_type = KERN_TYPE_SHA256;
8699 dgst_size = DGST_SIZE_4_8;
8700 parse_func = cisco4_parse_hash;
8701 sort_by_digest = sort_by_digest_4_8;
8702 opti_type = OPTI_TYPE_ZERO_BYTE
8703 | OPTI_TYPE_PRECOMPUTE_INIT
8704 | OPTI_TYPE_PRECOMPUTE_MERKLE
8705 | OPTI_TYPE_EARLY_SKIP
8706 | OPTI_TYPE_NOT_ITERATED
8707 | OPTI_TYPE_NOT_SALTED
8708 | OPTI_TYPE_RAW_HASH;
8709 dgst_pos0 = 3;
8710 dgst_pos1 = 7;
8711 dgst_pos2 = 2;
8712 dgst_pos3 = 6;
8713 break;
8714
8715 case 5800: hash_type = HASH_TYPE_SHA1;
8716 salt_type = SALT_TYPE_INTERN;
8717 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8718 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8719 | OPTS_TYPE_ST_ADD80;
8720 kern_type = KERN_TYPE_ANDROIDPIN;
8721 dgst_size = DGST_SIZE_4_5;
8722 parse_func = androidpin_parse_hash;
8723 sort_by_digest = sort_by_digest_4_5;
8724 opti_type = OPTI_TYPE_ZERO_BYTE;
8725 dgst_pos0 = 0;
8726 dgst_pos1 = 1;
8727 dgst_pos2 = 2;
8728 dgst_pos3 = 3;
8729 break;
8730
8731 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8732 salt_type = SALT_TYPE_NONE;
8733 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8734 opts_type = OPTS_TYPE_PT_GENERATE_LE
8735 | OPTS_TYPE_PT_ADD80;
8736 kern_type = KERN_TYPE_RIPEMD160;
8737 dgst_size = DGST_SIZE_4_5;
8738 parse_func = ripemd160_parse_hash;
8739 sort_by_digest = sort_by_digest_4_5;
8740 opti_type = OPTI_TYPE_ZERO_BYTE;
8741 dgst_pos0 = 0;
8742 dgst_pos1 = 1;
8743 dgst_pos2 = 2;
8744 dgst_pos3 = 3;
8745 break;
8746
8747 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8748 salt_type = SALT_TYPE_NONE;
8749 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8750 opts_type = OPTS_TYPE_PT_GENERATE_BE
8751 | OPTS_TYPE_PT_ADD80;
8752 kern_type = KERN_TYPE_WHIRLPOOL;
8753 dgst_size = DGST_SIZE_4_16;
8754 parse_func = whirlpool_parse_hash;
8755 sort_by_digest = sort_by_digest_4_16;
8756 opti_type = OPTI_TYPE_ZERO_BYTE;
8757 dgst_pos0 = 0;
8758 dgst_pos1 = 1;
8759 dgst_pos2 = 2;
8760 dgst_pos3 = 3;
8761 break;
8762
8763 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8764 salt_type = SALT_TYPE_EMBEDDED;
8765 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8766 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8767 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8768 dgst_size = DGST_SIZE_4_5;
8769 parse_func = truecrypt_parse_hash_2k;
8770 sort_by_digest = sort_by_digest_4_5;
8771 opti_type = OPTI_TYPE_ZERO_BYTE;
8772 dgst_pos0 = 0;
8773 dgst_pos1 = 1;
8774 dgst_pos2 = 2;
8775 dgst_pos3 = 3;
8776 break;
8777
8778 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8779 salt_type = SALT_TYPE_EMBEDDED;
8780 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8781 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8782 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8783 dgst_size = DGST_SIZE_4_5;
8784 parse_func = truecrypt_parse_hash_2k;
8785 sort_by_digest = sort_by_digest_4_5;
8786 opti_type = OPTI_TYPE_ZERO_BYTE;
8787 dgst_pos0 = 0;
8788 dgst_pos1 = 1;
8789 dgst_pos2 = 2;
8790 dgst_pos3 = 3;
8791 break;
8792
8793 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8794 salt_type = SALT_TYPE_EMBEDDED;
8795 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8796 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8797 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8798 dgst_size = DGST_SIZE_4_5;
8799 parse_func = truecrypt_parse_hash_2k;
8800 sort_by_digest = sort_by_digest_4_5;
8801 opti_type = OPTI_TYPE_ZERO_BYTE;
8802 dgst_pos0 = 0;
8803 dgst_pos1 = 1;
8804 dgst_pos2 = 2;
8805 dgst_pos3 = 3;
8806 break;
8807
8808 case 6221: hash_type = HASH_TYPE_SHA512;
8809 salt_type = SALT_TYPE_EMBEDDED;
8810 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8811 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8812 kern_type = KERN_TYPE_TCSHA512_XTS512;
8813 dgst_size = DGST_SIZE_8_8;
8814 parse_func = truecrypt_parse_hash_1k;
8815 sort_by_digest = sort_by_digest_8_8;
8816 opti_type = OPTI_TYPE_ZERO_BYTE
8817 | OPTI_TYPE_USES_BITS_64;
8818 dgst_pos0 = 0;
8819 dgst_pos1 = 1;
8820 dgst_pos2 = 2;
8821 dgst_pos3 = 3;
8822 break;
8823
8824 case 6222: hash_type = HASH_TYPE_SHA512;
8825 salt_type = SALT_TYPE_EMBEDDED;
8826 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8827 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8828 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8829 dgst_size = DGST_SIZE_8_8;
8830 parse_func = truecrypt_parse_hash_1k;
8831 sort_by_digest = sort_by_digest_8_8;
8832 opti_type = OPTI_TYPE_ZERO_BYTE
8833 | OPTI_TYPE_USES_BITS_64;
8834 dgst_pos0 = 0;
8835 dgst_pos1 = 1;
8836 dgst_pos2 = 2;
8837 dgst_pos3 = 3;
8838 break;
8839
8840 case 6223: hash_type = HASH_TYPE_SHA512;
8841 salt_type = SALT_TYPE_EMBEDDED;
8842 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8843 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8844 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8845 dgst_size = DGST_SIZE_8_8;
8846 parse_func = truecrypt_parse_hash_1k;
8847 sort_by_digest = sort_by_digest_8_8;
8848 opti_type = OPTI_TYPE_ZERO_BYTE
8849 | OPTI_TYPE_USES_BITS_64;
8850 dgst_pos0 = 0;
8851 dgst_pos1 = 1;
8852 dgst_pos2 = 2;
8853 dgst_pos3 = 3;
8854 break;
8855
8856 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8857 salt_type = SALT_TYPE_EMBEDDED;
8858 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8859 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8860 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8861 dgst_size = DGST_SIZE_4_8;
8862 parse_func = truecrypt_parse_hash_1k;
8863 sort_by_digest = sort_by_digest_4_8;
8864 opti_type = OPTI_TYPE_ZERO_BYTE;
8865 dgst_pos0 = 0;
8866 dgst_pos1 = 1;
8867 dgst_pos2 = 2;
8868 dgst_pos3 = 3;
8869 break;
8870
8871 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8872 salt_type = SALT_TYPE_EMBEDDED;
8873 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8874 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8875 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8876 dgst_size = DGST_SIZE_4_8;
8877 parse_func = truecrypt_parse_hash_1k;
8878 sort_by_digest = sort_by_digest_4_8;
8879 opti_type = OPTI_TYPE_ZERO_BYTE;
8880 dgst_pos0 = 0;
8881 dgst_pos1 = 1;
8882 dgst_pos2 = 2;
8883 dgst_pos3 = 3;
8884 break;
8885
8886 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8887 salt_type = SALT_TYPE_EMBEDDED;
8888 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8889 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8890 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8891 dgst_size = DGST_SIZE_4_8;
8892 parse_func = truecrypt_parse_hash_1k;
8893 sort_by_digest = sort_by_digest_4_8;
8894 opti_type = OPTI_TYPE_ZERO_BYTE;
8895 dgst_pos0 = 0;
8896 dgst_pos1 = 1;
8897 dgst_pos2 = 2;
8898 dgst_pos3 = 3;
8899 break;
8900
8901 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8902 salt_type = SALT_TYPE_EMBEDDED;
8903 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8904 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8905 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8906 dgst_size = DGST_SIZE_4_5;
8907 parse_func = truecrypt_parse_hash_1k;
8908 sort_by_digest = sort_by_digest_4_5;
8909 opti_type = OPTI_TYPE_ZERO_BYTE;
8910 dgst_pos0 = 0;
8911 dgst_pos1 = 1;
8912 dgst_pos2 = 2;
8913 dgst_pos3 = 3;
8914 break;
8915
8916 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8917 salt_type = SALT_TYPE_EMBEDDED;
8918 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8919 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8920 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8921 dgst_size = DGST_SIZE_4_5;
8922 parse_func = truecrypt_parse_hash_1k;
8923 sort_by_digest = sort_by_digest_4_5;
8924 opti_type = OPTI_TYPE_ZERO_BYTE;
8925 dgst_pos0 = 0;
8926 dgst_pos1 = 1;
8927 dgst_pos2 = 2;
8928 dgst_pos3 = 3;
8929 break;
8930
8931 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8932 salt_type = SALT_TYPE_EMBEDDED;
8933 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8934 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8935 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8936 dgst_size = DGST_SIZE_4_5;
8937 parse_func = truecrypt_parse_hash_1k;
8938 sort_by_digest = sort_by_digest_4_5;
8939 opti_type = OPTI_TYPE_ZERO_BYTE;
8940 dgst_pos0 = 0;
8941 dgst_pos1 = 1;
8942 dgst_pos2 = 2;
8943 dgst_pos3 = 3;
8944 break;
8945
8946 case 6300: hash_type = HASH_TYPE_MD5;
8947 salt_type = SALT_TYPE_EMBEDDED;
8948 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8949 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8950 kern_type = KERN_TYPE_MD5AIX;
8951 dgst_size = DGST_SIZE_4_4;
8952 parse_func = md5aix_parse_hash;
8953 sort_by_digest = sort_by_digest_4_4;
8954 opti_type = OPTI_TYPE_ZERO_BYTE;
8955 dgst_pos0 = 0;
8956 dgst_pos1 = 1;
8957 dgst_pos2 = 2;
8958 dgst_pos3 = 3;
8959 break;
8960
8961 case 6400: hash_type = HASH_TYPE_SHA256;
8962 salt_type = SALT_TYPE_EMBEDDED;
8963 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8964 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8965 kern_type = KERN_TYPE_SHA256AIX;
8966 dgst_size = DGST_SIZE_4_8;
8967 parse_func = sha256aix_parse_hash;
8968 sort_by_digest = sort_by_digest_4_8;
8969 opti_type = OPTI_TYPE_ZERO_BYTE;
8970 dgst_pos0 = 0;
8971 dgst_pos1 = 1;
8972 dgst_pos2 = 2;
8973 dgst_pos3 = 3;
8974 break;
8975
8976 case 6500: hash_type = HASH_TYPE_SHA512;
8977 salt_type = SALT_TYPE_EMBEDDED;
8978 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8979 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8980 kern_type = KERN_TYPE_SHA512AIX;
8981 dgst_size = DGST_SIZE_8_8;
8982 parse_func = sha512aix_parse_hash;
8983 sort_by_digest = sort_by_digest_8_8;
8984 opti_type = OPTI_TYPE_ZERO_BYTE
8985 | OPTI_TYPE_USES_BITS_64;
8986 dgst_pos0 = 0;
8987 dgst_pos1 = 1;
8988 dgst_pos2 = 2;
8989 dgst_pos3 = 3;
8990 break;
8991
8992 case 6600: hash_type = HASH_TYPE_AES;
8993 salt_type = SALT_TYPE_EMBEDDED;
8994 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8995 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8996 kern_type = KERN_TYPE_AGILEKEY;
8997 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
8998 parse_func = agilekey_parse_hash;
8999 sort_by_digest = sort_by_digest_4_5;
9000 opti_type = OPTI_TYPE_ZERO_BYTE;
9001 dgst_pos0 = 0;
9002 dgst_pos1 = 1;
9003 dgst_pos2 = 2;
9004 dgst_pos3 = 3;
9005 break;
9006
9007 case 6700: hash_type = HASH_TYPE_SHA1;
9008 salt_type = SALT_TYPE_EMBEDDED;
9009 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9010 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9011 kern_type = KERN_TYPE_SHA1AIX;
9012 dgst_size = DGST_SIZE_4_5;
9013 parse_func = sha1aix_parse_hash;
9014 sort_by_digest = sort_by_digest_4_5;
9015 opti_type = OPTI_TYPE_ZERO_BYTE;
9016 dgst_pos0 = 0;
9017 dgst_pos1 = 1;
9018 dgst_pos2 = 2;
9019 dgst_pos3 = 3;
9020 break;
9021
9022 case 6800: hash_type = HASH_TYPE_AES;
9023 salt_type = SALT_TYPE_EMBEDDED;
9024 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9025 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9026 kern_type = KERN_TYPE_LASTPASS;
9027 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9028 parse_func = lastpass_parse_hash;
9029 sort_by_digest = sort_by_digest_4_8;
9030 opti_type = OPTI_TYPE_ZERO_BYTE;
9031 dgst_pos0 = 0;
9032 dgst_pos1 = 1;
9033 dgst_pos2 = 2;
9034 dgst_pos3 = 3;
9035 break;
9036
9037 case 6900: hash_type = HASH_TYPE_GOST;
9038 salt_type = SALT_TYPE_NONE;
9039 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9040 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9041 kern_type = KERN_TYPE_GOST;
9042 dgst_size = DGST_SIZE_4_8;
9043 parse_func = gost_parse_hash;
9044 sort_by_digest = sort_by_digest_4_8;
9045 opti_type = OPTI_TYPE_ZERO_BYTE;
9046 dgst_pos0 = 0;
9047 dgst_pos1 = 1;
9048 dgst_pos2 = 2;
9049 dgst_pos3 = 3;
9050 break;
9051
9052 case 7100: hash_type = HASH_TYPE_SHA512;
9053 salt_type = SALT_TYPE_EMBEDDED;
9054 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9055 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9056 kern_type = KERN_TYPE_PBKDF2_SHA512;
9057 dgst_size = DGST_SIZE_8_16;
9058 parse_func = sha512osx_parse_hash;
9059 sort_by_digest = sort_by_digest_8_16;
9060 opti_type = OPTI_TYPE_ZERO_BYTE
9061 | OPTI_TYPE_USES_BITS_64;
9062 dgst_pos0 = 0;
9063 dgst_pos1 = 1;
9064 dgst_pos2 = 2;
9065 dgst_pos3 = 3;
9066 break;
9067
9068 case 7200: hash_type = HASH_TYPE_SHA512;
9069 salt_type = SALT_TYPE_EMBEDDED;
9070 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9071 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9072 kern_type = KERN_TYPE_PBKDF2_SHA512;
9073 dgst_size = DGST_SIZE_8_16;
9074 parse_func = sha512grub_parse_hash;
9075 sort_by_digest = sort_by_digest_8_16;
9076 opti_type = OPTI_TYPE_ZERO_BYTE
9077 | OPTI_TYPE_USES_BITS_64;
9078 dgst_pos0 = 0;
9079 dgst_pos1 = 1;
9080 dgst_pos2 = 2;
9081 dgst_pos3 = 3;
9082 break;
9083
9084 case 7300: hash_type = HASH_TYPE_SHA1;
9085 salt_type = SALT_TYPE_EMBEDDED;
9086 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9087 opts_type = OPTS_TYPE_PT_GENERATE_BE
9088 | OPTS_TYPE_ST_ADD80
9089 | OPTS_TYPE_ST_ADDBITS15;
9090 kern_type = KERN_TYPE_RAKP;
9091 dgst_size = DGST_SIZE_4_5;
9092 parse_func = rakp_parse_hash;
9093 sort_by_digest = sort_by_digest_4_5;
9094 opti_type = OPTI_TYPE_ZERO_BYTE
9095 | OPTI_TYPE_NOT_ITERATED;
9096 dgst_pos0 = 3;
9097 dgst_pos1 = 4;
9098 dgst_pos2 = 2;
9099 dgst_pos3 = 1;
9100 break;
9101
9102 case 7400: hash_type = HASH_TYPE_SHA256;
9103 salt_type = SALT_TYPE_EMBEDDED;
9104 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9105 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9106 kern_type = KERN_TYPE_SHA256CRYPT;
9107 dgst_size = DGST_SIZE_4_8;
9108 parse_func = sha256crypt_parse_hash;
9109 sort_by_digest = sort_by_digest_4_8;
9110 opti_type = OPTI_TYPE_ZERO_BYTE;
9111 dgst_pos0 = 0;
9112 dgst_pos1 = 1;
9113 dgst_pos2 = 2;
9114 dgst_pos3 = 3;
9115 break;
9116
9117 case 7500: hash_type = HASH_TYPE_KRB5PA;
9118 salt_type = SALT_TYPE_EMBEDDED;
9119 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9120 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9121 kern_type = KERN_TYPE_KRB5PA;
9122 dgst_size = DGST_SIZE_4_4;
9123 parse_func = krb5pa_parse_hash;
9124 sort_by_digest = sort_by_digest_4_4;
9125 opti_type = OPTI_TYPE_ZERO_BYTE
9126 | OPTI_TYPE_NOT_ITERATED;
9127 dgst_pos0 = 0;
9128 dgst_pos1 = 1;
9129 dgst_pos2 = 2;
9130 dgst_pos3 = 3;
9131 break;
9132
9133 case 7600: hash_type = HASH_TYPE_SHA1;
9134 salt_type = SALT_TYPE_INTERN;
9135 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9136 opts_type = OPTS_TYPE_PT_GENERATE_BE
9137 | OPTS_TYPE_PT_ADD80
9138 | OPTS_TYPE_PT_ADDBITS15;
9139 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9140 dgst_size = DGST_SIZE_4_5;
9141 parse_func = redmine_parse_hash;
9142 sort_by_digest = sort_by_digest_4_5;
9143 opti_type = OPTI_TYPE_ZERO_BYTE
9144 | OPTI_TYPE_PRECOMPUTE_INIT
9145 | OPTI_TYPE_EARLY_SKIP
9146 | OPTI_TYPE_NOT_ITERATED
9147 | OPTI_TYPE_PREPENDED_SALT;
9148 dgst_pos0 = 3;
9149 dgst_pos1 = 4;
9150 dgst_pos2 = 2;
9151 dgst_pos3 = 1;
9152 break;
9153
9154 case 7700: hash_type = HASH_TYPE_SAPB;
9155 salt_type = SALT_TYPE_EMBEDDED;
9156 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9157 opts_type = OPTS_TYPE_PT_GENERATE_LE
9158 | OPTS_TYPE_PT_UPPER
9159 | OPTS_TYPE_ST_UPPER;
9160 kern_type = KERN_TYPE_SAPB;
9161 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9162 parse_func = sapb_parse_hash;
9163 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9164 opti_type = OPTI_TYPE_ZERO_BYTE
9165 | OPTI_TYPE_PRECOMPUTE_INIT
9166 | OPTI_TYPE_NOT_ITERATED;
9167 dgst_pos0 = 0;
9168 dgst_pos1 = 1;
9169 dgst_pos2 = 2;
9170 dgst_pos3 = 3;
9171 break;
9172
9173 case 7800: hash_type = HASH_TYPE_SAPG;
9174 salt_type = SALT_TYPE_EMBEDDED;
9175 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9176 opts_type = OPTS_TYPE_PT_GENERATE_BE
9177 | OPTS_TYPE_ST_ADD80
9178 | OPTS_TYPE_ST_UPPER;
9179 kern_type = KERN_TYPE_SAPG;
9180 dgst_size = DGST_SIZE_4_5;
9181 parse_func = sapg_parse_hash;
9182 sort_by_digest = sort_by_digest_4_5;
9183 opti_type = OPTI_TYPE_ZERO_BYTE
9184 | OPTI_TYPE_PRECOMPUTE_INIT
9185 | OPTI_TYPE_NOT_ITERATED;
9186 dgst_pos0 = 3;
9187 dgst_pos1 = 4;
9188 dgst_pos2 = 2;
9189 dgst_pos3 = 1;
9190 break;
9191
9192 case 7900: hash_type = HASH_TYPE_SHA512;
9193 salt_type = SALT_TYPE_EMBEDDED;
9194 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9195 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9196 kern_type = KERN_TYPE_DRUPAL7;
9197 dgst_size = DGST_SIZE_8_8;
9198 parse_func = drupal7_parse_hash;
9199 sort_by_digest = sort_by_digest_8_8;
9200 opti_type = OPTI_TYPE_ZERO_BYTE
9201 | OPTI_TYPE_USES_BITS_64;
9202 dgst_pos0 = 0;
9203 dgst_pos1 = 1;
9204 dgst_pos2 = 2;
9205 dgst_pos3 = 3;
9206 break;
9207
9208 case 8000: hash_type = HASH_TYPE_SHA256;
9209 salt_type = SALT_TYPE_EMBEDDED;
9210 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9211 opts_type = OPTS_TYPE_PT_GENERATE_BE
9212 | OPTS_TYPE_PT_UNICODE
9213 | OPTS_TYPE_ST_ADD80
9214 | OPTS_TYPE_ST_HEX;
9215 kern_type = KERN_TYPE_SYBASEASE;
9216 dgst_size = DGST_SIZE_4_8;
9217 parse_func = sybasease_parse_hash;
9218 sort_by_digest = sort_by_digest_4_8;
9219 opti_type = OPTI_TYPE_ZERO_BYTE
9220 | OPTI_TYPE_PRECOMPUTE_INIT
9221 | OPTI_TYPE_EARLY_SKIP
9222 | OPTI_TYPE_NOT_ITERATED
9223 | OPTI_TYPE_RAW_HASH;
9224 dgst_pos0 = 3;
9225 dgst_pos1 = 7;
9226 dgst_pos2 = 2;
9227 dgst_pos3 = 6;
9228 break;
9229
9230 case 8100: hash_type = HASH_TYPE_SHA1;
9231 salt_type = SALT_TYPE_EMBEDDED;
9232 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9233 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9234 kern_type = KERN_TYPE_NETSCALER;
9235 dgst_size = DGST_SIZE_4_5;
9236 parse_func = netscaler_parse_hash;
9237 sort_by_digest = sort_by_digest_4_5;
9238 opti_type = OPTI_TYPE_ZERO_BYTE
9239 | OPTI_TYPE_PRECOMPUTE_INIT
9240 | OPTI_TYPE_PRECOMPUTE_MERKLE
9241 | OPTI_TYPE_EARLY_SKIP
9242 | OPTI_TYPE_NOT_ITERATED
9243 | OPTI_TYPE_PREPENDED_SALT
9244 | OPTI_TYPE_RAW_HASH;
9245 dgst_pos0 = 3;
9246 dgst_pos1 = 4;
9247 dgst_pos2 = 2;
9248 dgst_pos3 = 1;
9249 break;
9250
9251 case 8200: hash_type = HASH_TYPE_SHA256;
9252 salt_type = SALT_TYPE_EMBEDDED;
9253 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9254 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9255 kern_type = KERN_TYPE_CLOUDKEY;
9256 dgst_size = DGST_SIZE_4_8;
9257 parse_func = cloudkey_parse_hash;
9258 sort_by_digest = sort_by_digest_4_8;
9259 opti_type = OPTI_TYPE_ZERO_BYTE;
9260 dgst_pos0 = 0;
9261 dgst_pos1 = 1;
9262 dgst_pos2 = 2;
9263 dgst_pos3 = 3;
9264 break;
9265
9266 case 8300: hash_type = HASH_TYPE_SHA1;
9267 salt_type = SALT_TYPE_EMBEDDED;
9268 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9269 opts_type = OPTS_TYPE_PT_GENERATE_LE
9270 | OPTS_TYPE_ST_HEX
9271 | OPTS_TYPE_ST_ADD80;
9272 kern_type = KERN_TYPE_NSEC3;
9273 dgst_size = DGST_SIZE_4_5;
9274 parse_func = nsec3_parse_hash;
9275 sort_by_digest = sort_by_digest_4_5;
9276 opti_type = OPTI_TYPE_ZERO_BYTE;
9277 dgst_pos0 = 3;
9278 dgst_pos1 = 4;
9279 dgst_pos2 = 2;
9280 dgst_pos3 = 1;
9281 break;
9282
9283 case 8400: hash_type = HASH_TYPE_SHA1;
9284 salt_type = SALT_TYPE_INTERN;
9285 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9286 opts_type = OPTS_TYPE_PT_GENERATE_BE
9287 | OPTS_TYPE_PT_ADD80
9288 | OPTS_TYPE_PT_ADDBITS15;
9289 kern_type = KERN_TYPE_WBB3;
9290 dgst_size = DGST_SIZE_4_5;
9291 parse_func = wbb3_parse_hash;
9292 sort_by_digest = sort_by_digest_4_5;
9293 opti_type = OPTI_TYPE_ZERO_BYTE
9294 | OPTI_TYPE_PRECOMPUTE_INIT
9295 | OPTI_TYPE_NOT_ITERATED;
9296 dgst_pos0 = 3;
9297 dgst_pos1 = 4;
9298 dgst_pos2 = 2;
9299 dgst_pos3 = 1;
9300 break;
9301
9302 case 8500: hash_type = HASH_TYPE_DESRACF;
9303 salt_type = SALT_TYPE_EMBEDDED;
9304 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9305 opts_type = OPTS_TYPE_PT_GENERATE_LE
9306 | OPTS_TYPE_ST_UPPER;
9307 kern_type = KERN_TYPE_RACF;
9308 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9309 parse_func = racf_parse_hash;
9310 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9311 opti_type = OPTI_TYPE_ZERO_BYTE
9312 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9313 dgst_pos0 = 0;
9314 dgst_pos1 = 1;
9315 dgst_pos2 = 2;
9316 dgst_pos3 = 3;
9317 break;
9318
9319 case 8600: hash_type = HASH_TYPE_LOTUS5;
9320 salt_type = SALT_TYPE_NONE;
9321 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9322 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9323 kern_type = KERN_TYPE_LOTUS5;
9324 dgst_size = DGST_SIZE_4_4;
9325 parse_func = lotus5_parse_hash;
9326 sort_by_digest = sort_by_digest_4_4;
9327 opti_type = OPTI_TYPE_EARLY_SKIP
9328 | OPTI_TYPE_NOT_ITERATED
9329 | OPTI_TYPE_NOT_SALTED
9330 | OPTI_TYPE_RAW_HASH;
9331 dgst_pos0 = 0;
9332 dgst_pos1 = 1;
9333 dgst_pos2 = 2;
9334 dgst_pos3 = 3;
9335 break;
9336
9337 case 8700: hash_type = HASH_TYPE_LOTUS6;
9338 salt_type = SALT_TYPE_EMBEDDED;
9339 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9340 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9341 kern_type = KERN_TYPE_LOTUS6;
9342 dgst_size = DGST_SIZE_4_4;
9343 parse_func = lotus6_parse_hash;
9344 sort_by_digest = sort_by_digest_4_4;
9345 opti_type = OPTI_TYPE_EARLY_SKIP
9346 | OPTI_TYPE_NOT_ITERATED
9347 | OPTI_TYPE_RAW_HASH;
9348 dgst_pos0 = 0;
9349 dgst_pos1 = 1;
9350 dgst_pos2 = 2;
9351 dgst_pos3 = 3;
9352 break;
9353
9354 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9355 salt_type = SALT_TYPE_EMBEDDED;
9356 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9357 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9358 kern_type = KERN_TYPE_ANDROIDFDE;
9359 dgst_size = DGST_SIZE_4_4;
9360 parse_func = androidfde_parse_hash;
9361 sort_by_digest = sort_by_digest_4_4;
9362 opti_type = OPTI_TYPE_ZERO_BYTE;
9363 dgst_pos0 = 0;
9364 dgst_pos1 = 1;
9365 dgst_pos2 = 2;
9366 dgst_pos3 = 3;
9367 break;
9368
9369 case 8900: hash_type = HASH_TYPE_SCRYPT;
9370 salt_type = SALT_TYPE_EMBEDDED;
9371 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9372 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9373 kern_type = KERN_TYPE_SCRYPT;
9374 dgst_size = DGST_SIZE_4_8;
9375 parse_func = scrypt_parse_hash;
9376 sort_by_digest = sort_by_digest_4_8;
9377 opti_type = OPTI_TYPE_ZERO_BYTE;
9378 dgst_pos0 = 0;
9379 dgst_pos1 = 1;
9380 dgst_pos2 = 2;
9381 dgst_pos3 = 3;
9382 break;
9383
9384 case 9000: hash_type = HASH_TYPE_SHA1;
9385 salt_type = SALT_TYPE_EMBEDDED;
9386 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9387 opts_type = OPTS_TYPE_PT_GENERATE_LE
9388 | OPTS_TYPE_ST_GENERATE_LE;
9389 kern_type = KERN_TYPE_PSAFE2;
9390 dgst_size = DGST_SIZE_4_5;
9391 parse_func = psafe2_parse_hash;
9392 sort_by_digest = sort_by_digest_4_5;
9393 opti_type = OPTI_TYPE_ZERO_BYTE;
9394 dgst_pos0 = 0;
9395 dgst_pos1 = 1;
9396 dgst_pos2 = 2;
9397 dgst_pos3 = 3;
9398 break;
9399
9400 case 9100: hash_type = HASH_TYPE_LOTUS8;
9401 salt_type = SALT_TYPE_EMBEDDED;
9402 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9403 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9404 kern_type = KERN_TYPE_LOTUS8;
9405 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9406 parse_func = lotus8_parse_hash;
9407 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9408 opti_type = OPTI_TYPE_ZERO_BYTE;
9409 dgst_pos0 = 0;
9410 dgst_pos1 = 1;
9411 dgst_pos2 = 2;
9412 dgst_pos3 = 3;
9413 break;
9414
9415 case 9200: hash_type = HASH_TYPE_SHA256;
9416 salt_type = SALT_TYPE_EMBEDDED;
9417 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9418 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9419 kern_type = KERN_TYPE_PBKDF2_SHA256;
9420 dgst_size = DGST_SIZE_4_32;
9421 parse_func = cisco8_parse_hash;
9422 sort_by_digest = sort_by_digest_4_32;
9423 opti_type = OPTI_TYPE_ZERO_BYTE;
9424 dgst_pos0 = 0;
9425 dgst_pos1 = 1;
9426 dgst_pos2 = 2;
9427 dgst_pos3 = 3;
9428 break;
9429
9430 case 9300: hash_type = HASH_TYPE_SCRYPT;
9431 salt_type = SALT_TYPE_EMBEDDED;
9432 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9433 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9434 kern_type = KERN_TYPE_SCRYPT;
9435 dgst_size = DGST_SIZE_4_8;
9436 parse_func = cisco9_parse_hash;
9437 sort_by_digest = sort_by_digest_4_8;
9438 opti_type = OPTI_TYPE_ZERO_BYTE;
9439 dgst_pos0 = 0;
9440 dgst_pos1 = 1;
9441 dgst_pos2 = 2;
9442 dgst_pos3 = 3;
9443 break;
9444
9445 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9446 salt_type = SALT_TYPE_EMBEDDED;
9447 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9448 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9449 kern_type = KERN_TYPE_OFFICE2007;
9450 dgst_size = DGST_SIZE_4_4;
9451 parse_func = office2007_parse_hash;
9452 sort_by_digest = sort_by_digest_4_4;
9453 opti_type = OPTI_TYPE_ZERO_BYTE;
9454 dgst_pos0 = 0;
9455 dgst_pos1 = 1;
9456 dgst_pos2 = 2;
9457 dgst_pos3 = 3;
9458 break;
9459
9460 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9461 salt_type = SALT_TYPE_EMBEDDED;
9462 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9463 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9464 kern_type = KERN_TYPE_OFFICE2010;
9465 dgst_size = DGST_SIZE_4_4;
9466 parse_func = office2010_parse_hash;
9467 sort_by_digest = sort_by_digest_4_4;
9468 opti_type = OPTI_TYPE_ZERO_BYTE;
9469 dgst_pos0 = 0;
9470 dgst_pos1 = 1;
9471 dgst_pos2 = 2;
9472 dgst_pos3 = 3;
9473 break;
9474
9475 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9476 salt_type = SALT_TYPE_EMBEDDED;
9477 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9478 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9479 kern_type = KERN_TYPE_OFFICE2013;
9480 dgst_size = DGST_SIZE_4_4;
9481 parse_func = office2013_parse_hash;
9482 sort_by_digest = sort_by_digest_4_4;
9483 opti_type = OPTI_TYPE_ZERO_BYTE;
9484 dgst_pos0 = 0;
9485 dgst_pos1 = 1;
9486 dgst_pos2 = 2;
9487 dgst_pos3 = 3;
9488 break;
9489
9490 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9491 salt_type = SALT_TYPE_EMBEDDED;
9492 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9493 opts_type = OPTS_TYPE_PT_GENERATE_LE
9494 | OPTS_TYPE_PT_ADD80
9495 | OPTS_TYPE_PT_UNICODE;
9496 kern_type = KERN_TYPE_OLDOFFICE01;
9497 dgst_size = DGST_SIZE_4_4;
9498 parse_func = oldoffice01_parse_hash;
9499 sort_by_digest = sort_by_digest_4_4;
9500 opti_type = OPTI_TYPE_ZERO_BYTE
9501 | OPTI_TYPE_PRECOMPUTE_INIT
9502 | OPTI_TYPE_NOT_ITERATED;
9503 dgst_pos0 = 0;
9504 dgst_pos1 = 1;
9505 dgst_pos2 = 2;
9506 dgst_pos3 = 3;
9507 break;
9508
9509 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9510 salt_type = SALT_TYPE_EMBEDDED;
9511 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9512 opts_type = OPTS_TYPE_PT_GENERATE_LE
9513 | OPTS_TYPE_PT_ADD80;
9514 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9515 dgst_size = DGST_SIZE_4_4;
9516 parse_func = oldoffice01cm1_parse_hash;
9517 sort_by_digest = sort_by_digest_4_4;
9518 opti_type = OPTI_TYPE_ZERO_BYTE
9519 | OPTI_TYPE_PRECOMPUTE_INIT
9520 | OPTI_TYPE_NOT_ITERATED;
9521 dgst_pos0 = 0;
9522 dgst_pos1 = 1;
9523 dgst_pos2 = 2;
9524 dgst_pos3 = 3;
9525 break;
9526
9527 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9528 salt_type = SALT_TYPE_EMBEDDED;
9529 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9530 opts_type = OPTS_TYPE_PT_GENERATE_LE
9531 | OPTS_TYPE_PT_ADD80
9532 | OPTS_TYPE_PT_UNICODE
9533 | OPTS_TYPE_PT_NEVERCRACK;
9534 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9535 dgst_size = DGST_SIZE_4_4;
9536 parse_func = oldoffice01cm2_parse_hash;
9537 sort_by_digest = sort_by_digest_4_4;
9538 opti_type = OPTI_TYPE_ZERO_BYTE
9539 | OPTI_TYPE_PRECOMPUTE_INIT
9540 | OPTI_TYPE_NOT_ITERATED;
9541 dgst_pos0 = 0;
9542 dgst_pos1 = 1;
9543 dgst_pos2 = 2;
9544 dgst_pos3 = 3;
9545 break;
9546
9547 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9548 salt_type = SALT_TYPE_EMBEDDED;
9549 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9550 opts_type = OPTS_TYPE_PT_GENERATE_BE
9551 | OPTS_TYPE_PT_ADD80
9552 | OPTS_TYPE_PT_UNICODE;
9553 kern_type = KERN_TYPE_OLDOFFICE34;
9554 dgst_size = DGST_SIZE_4_4;
9555 parse_func = oldoffice34_parse_hash;
9556 sort_by_digest = sort_by_digest_4_4;
9557 opti_type = OPTI_TYPE_ZERO_BYTE
9558 | OPTI_TYPE_PRECOMPUTE_INIT
9559 | OPTI_TYPE_NOT_ITERATED;
9560 dgst_pos0 = 0;
9561 dgst_pos1 = 1;
9562 dgst_pos2 = 2;
9563 dgst_pos3 = 3;
9564 break;
9565
9566 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9567 salt_type = SALT_TYPE_EMBEDDED;
9568 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9569 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9570 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9571 dgst_size = DGST_SIZE_4_4;
9572 parse_func = oldoffice34cm1_parse_hash;
9573 sort_by_digest = sort_by_digest_4_4;
9574 opti_type = OPTI_TYPE_ZERO_BYTE
9575 | OPTI_TYPE_PRECOMPUTE_INIT
9576 | OPTI_TYPE_NOT_ITERATED;
9577 dgst_pos0 = 0;
9578 dgst_pos1 = 1;
9579 dgst_pos2 = 2;
9580 dgst_pos3 = 3;
9581 break;
9582
9583 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9584 salt_type = SALT_TYPE_EMBEDDED;
9585 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9586 opts_type = OPTS_TYPE_PT_GENERATE_BE
9587 | OPTS_TYPE_PT_ADD80
9588 | OPTS_TYPE_PT_UNICODE
9589 | OPTS_TYPE_PT_NEVERCRACK;
9590 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9591 dgst_size = DGST_SIZE_4_4;
9592 parse_func = oldoffice34cm2_parse_hash;
9593 sort_by_digest = sort_by_digest_4_4;
9594 opti_type = OPTI_TYPE_ZERO_BYTE
9595 | OPTI_TYPE_PRECOMPUTE_INIT
9596 | OPTI_TYPE_NOT_ITERATED;
9597 dgst_pos0 = 0;
9598 dgst_pos1 = 1;
9599 dgst_pos2 = 2;
9600 dgst_pos3 = 3;
9601 break;
9602
9603 case 9900: hash_type = HASH_TYPE_MD5;
9604 salt_type = SALT_TYPE_NONE;
9605 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9606 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9607 kern_type = KERN_TYPE_RADMIN2;
9608 dgst_size = DGST_SIZE_4_4;
9609 parse_func = radmin2_parse_hash;
9610 sort_by_digest = sort_by_digest_4_4;
9611 opti_type = OPTI_TYPE_ZERO_BYTE
9612 | OPTI_TYPE_PRECOMPUTE_INIT
9613 | OPTI_TYPE_EARLY_SKIP
9614 | OPTI_TYPE_NOT_ITERATED
9615 | OPTI_TYPE_NOT_SALTED;
9616 dgst_pos0 = 0;
9617 dgst_pos1 = 3;
9618 dgst_pos2 = 2;
9619 dgst_pos3 = 1;
9620 break;
9621
9622 case 10000: hash_type = HASH_TYPE_SHA256;
9623 salt_type = SALT_TYPE_EMBEDDED;
9624 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9625 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9626 kern_type = KERN_TYPE_PBKDF2_SHA256;
9627 dgst_size = DGST_SIZE_4_32;
9628 parse_func = djangopbkdf2_parse_hash;
9629 sort_by_digest = sort_by_digest_4_32;
9630 opti_type = OPTI_TYPE_ZERO_BYTE;
9631 dgst_pos0 = 0;
9632 dgst_pos1 = 1;
9633 dgst_pos2 = 2;
9634 dgst_pos3 = 3;
9635 break;
9636
9637 case 10100: hash_type = HASH_TYPE_SIPHASH;
9638 salt_type = SALT_TYPE_EMBEDDED;
9639 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9640 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9641 kern_type = KERN_TYPE_SIPHASH;
9642 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9643 parse_func = siphash_parse_hash;
9644 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9645 opti_type = OPTI_TYPE_ZERO_BYTE
9646 | OPTI_TYPE_NOT_ITERATED
9647 | OPTI_TYPE_RAW_HASH;
9648 dgst_pos0 = 0;
9649 dgst_pos1 = 1;
9650 dgst_pos2 = 2;
9651 dgst_pos3 = 3;
9652 break;
9653
9654 case 10200: hash_type = HASH_TYPE_MD5;
9655 salt_type = SALT_TYPE_EMBEDDED;
9656 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9657 opts_type = OPTS_TYPE_PT_GENERATE_LE
9658 | OPTS_TYPE_ST_ADD80
9659 | OPTS_TYPE_ST_ADDBITS14;
9660 kern_type = KERN_TYPE_HMACMD5_PW;
9661 dgst_size = DGST_SIZE_4_4;
9662 parse_func = crammd5_parse_hash;
9663 sort_by_digest = sort_by_digest_4_4;
9664 opti_type = OPTI_TYPE_ZERO_BYTE
9665 | OPTI_TYPE_NOT_ITERATED;
9666 dgst_pos0 = 0;
9667 dgst_pos1 = 3;
9668 dgst_pos2 = 2;
9669 dgst_pos3 = 1;
9670 break;
9671
9672 case 10300: hash_type = HASH_TYPE_SHA1;
9673 salt_type = SALT_TYPE_EMBEDDED;
9674 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9675 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9676 kern_type = KERN_TYPE_SAPH_SHA1;
9677 dgst_size = DGST_SIZE_4_5;
9678 parse_func = saph_sha1_parse_hash;
9679 sort_by_digest = sort_by_digest_4_5;
9680 opti_type = OPTI_TYPE_ZERO_BYTE;
9681 dgst_pos0 = 0;
9682 dgst_pos1 = 1;
9683 dgst_pos2 = 2;
9684 dgst_pos3 = 3;
9685 break;
9686
9687 case 10400: hash_type = HASH_TYPE_PDFU16;
9688 salt_type = SALT_TYPE_EMBEDDED;
9689 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9690 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9691 kern_type = KERN_TYPE_PDF11;
9692 dgst_size = DGST_SIZE_4_4;
9693 parse_func = pdf11_parse_hash;
9694 sort_by_digest = sort_by_digest_4_4;
9695 opti_type = OPTI_TYPE_ZERO_BYTE
9696 | OPTI_TYPE_NOT_ITERATED;
9697 dgst_pos0 = 0;
9698 dgst_pos1 = 1;
9699 dgst_pos2 = 2;
9700 dgst_pos3 = 3;
9701 break;
9702
9703 case 10410: hash_type = HASH_TYPE_PDFU16;
9704 salt_type = SALT_TYPE_EMBEDDED;
9705 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9706 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9707 kern_type = KERN_TYPE_PDF11CM1;
9708 dgst_size = DGST_SIZE_4_4;
9709 parse_func = pdf11cm1_parse_hash;
9710 sort_by_digest = sort_by_digest_4_4;
9711 opti_type = OPTI_TYPE_ZERO_BYTE
9712 | OPTI_TYPE_NOT_ITERATED;
9713 dgst_pos0 = 0;
9714 dgst_pos1 = 1;
9715 dgst_pos2 = 2;
9716 dgst_pos3 = 3;
9717 break;
9718
9719 case 10420: hash_type = HASH_TYPE_PDFU16;
9720 salt_type = SALT_TYPE_EMBEDDED;
9721 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9722 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9723 kern_type = KERN_TYPE_PDF11CM2;
9724 dgst_size = DGST_SIZE_4_4;
9725 parse_func = pdf11cm2_parse_hash;
9726 sort_by_digest = sort_by_digest_4_4;
9727 opti_type = OPTI_TYPE_ZERO_BYTE
9728 | OPTI_TYPE_NOT_ITERATED;
9729 dgst_pos0 = 0;
9730 dgst_pos1 = 1;
9731 dgst_pos2 = 2;
9732 dgst_pos3 = 3;
9733 break;
9734
9735 case 10500: hash_type = HASH_TYPE_PDFU16;
9736 salt_type = SALT_TYPE_EMBEDDED;
9737 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9738 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9739 kern_type = KERN_TYPE_PDF14;
9740 dgst_size = DGST_SIZE_4_4;
9741 parse_func = pdf14_parse_hash;
9742 sort_by_digest = sort_by_digest_4_4;
9743 opti_type = OPTI_TYPE_ZERO_BYTE
9744 | OPTI_TYPE_NOT_ITERATED;
9745 dgst_pos0 = 0;
9746 dgst_pos1 = 1;
9747 dgst_pos2 = 2;
9748 dgst_pos3 = 3;
9749 break;
9750
9751 case 10600: hash_type = HASH_TYPE_SHA256;
9752 salt_type = SALT_TYPE_EMBEDDED;
9753 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9754 opts_type = OPTS_TYPE_PT_GENERATE_BE
9755 | OPTS_TYPE_ST_ADD80
9756 | OPTS_TYPE_ST_ADDBITS15
9757 | OPTS_TYPE_HASH_COPY;
9758 kern_type = KERN_TYPE_SHA256_PWSLT;
9759 dgst_size = DGST_SIZE_4_8;
9760 parse_func = pdf17l3_parse_hash;
9761 sort_by_digest = sort_by_digest_4_8;
9762 opti_type = OPTI_TYPE_ZERO_BYTE
9763 | OPTI_TYPE_PRECOMPUTE_INIT
9764 | OPTI_TYPE_PRECOMPUTE_MERKLE
9765 | OPTI_TYPE_EARLY_SKIP
9766 | OPTI_TYPE_NOT_ITERATED
9767 | OPTI_TYPE_APPENDED_SALT
9768 | OPTI_TYPE_RAW_HASH;
9769 dgst_pos0 = 3;
9770 dgst_pos1 = 7;
9771 dgst_pos2 = 2;
9772 dgst_pos3 = 6;
9773 break;
9774
9775 case 10700: hash_type = HASH_TYPE_PDFU32;
9776 salt_type = SALT_TYPE_EMBEDDED;
9777 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9778 opts_type = OPTS_TYPE_PT_GENERATE_LE
9779 | OPTS_TYPE_HASH_COPY;
9780 kern_type = KERN_TYPE_PDF17L8;
9781 dgst_size = DGST_SIZE_4_8;
9782 parse_func = pdf17l8_parse_hash;
9783 sort_by_digest = sort_by_digest_4_8;
9784 opti_type = OPTI_TYPE_ZERO_BYTE
9785 | OPTI_TYPE_NOT_ITERATED;
9786 dgst_pos0 = 0;
9787 dgst_pos1 = 1;
9788 dgst_pos2 = 2;
9789 dgst_pos3 = 3;
9790 break;
9791
9792 case 10800: hash_type = HASH_TYPE_SHA384;
9793 salt_type = SALT_TYPE_NONE;
9794 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9795 opts_type = OPTS_TYPE_PT_GENERATE_BE
9796 | OPTS_TYPE_PT_ADD80
9797 | OPTS_TYPE_PT_ADDBITS15;
9798 kern_type = KERN_TYPE_SHA384;
9799 dgst_size = DGST_SIZE_8_8;
9800 parse_func = sha384_parse_hash;
9801 sort_by_digest = sort_by_digest_8_8;
9802 opti_type = OPTI_TYPE_ZERO_BYTE
9803 | OPTI_TYPE_PRECOMPUTE_INIT
9804 | OPTI_TYPE_PRECOMPUTE_MERKLE
9805 | OPTI_TYPE_EARLY_SKIP
9806 | OPTI_TYPE_NOT_ITERATED
9807 | OPTI_TYPE_NOT_SALTED
9808 | OPTI_TYPE_USES_BITS_64
9809 | OPTI_TYPE_RAW_HASH;
9810 dgst_pos0 = 6;
9811 dgst_pos1 = 7;
9812 dgst_pos2 = 4;
9813 dgst_pos3 = 5;
9814 break;
9815
9816 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9817 salt_type = SALT_TYPE_EMBEDDED;
9818 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9819 opts_type = OPTS_TYPE_PT_GENERATE_LE
9820 | OPTS_TYPE_ST_BASE64
9821 | OPTS_TYPE_HASH_COPY;
9822 kern_type = KERN_TYPE_PBKDF2_SHA256;
9823 dgst_size = DGST_SIZE_4_32;
9824 parse_func = pbkdf2_sha256_parse_hash;
9825 sort_by_digest = sort_by_digest_4_32;
9826 opti_type = OPTI_TYPE_ZERO_BYTE;
9827 dgst_pos0 = 0;
9828 dgst_pos1 = 1;
9829 dgst_pos2 = 2;
9830 dgst_pos3 = 3;
9831 break;
9832
9833 case 11000: hash_type = HASH_TYPE_MD5;
9834 salt_type = SALT_TYPE_INTERN;
9835 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9836 opts_type = OPTS_TYPE_PT_GENERATE_LE
9837 | OPTS_TYPE_PT_ADD80;
9838 kern_type = KERN_TYPE_PRESTASHOP;
9839 dgst_size = DGST_SIZE_4_4;
9840 parse_func = prestashop_parse_hash;
9841 sort_by_digest = sort_by_digest_4_4;
9842 opti_type = OPTI_TYPE_ZERO_BYTE
9843 | OPTI_TYPE_PRECOMPUTE_INIT
9844 | OPTI_TYPE_NOT_ITERATED
9845 | OPTI_TYPE_PREPENDED_SALT;
9846 dgst_pos0 = 0;
9847 dgst_pos1 = 3;
9848 dgst_pos2 = 2;
9849 dgst_pos3 = 1;
9850 break;
9851
9852 case 11100: hash_type = HASH_TYPE_MD5;
9853 salt_type = SALT_TYPE_EMBEDDED;
9854 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9855 opts_type = OPTS_TYPE_PT_GENERATE_LE
9856 | OPTS_TYPE_ST_ADD80;
9857 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9858 dgst_size = DGST_SIZE_4_4;
9859 parse_func = postgresql_auth_parse_hash;
9860 sort_by_digest = sort_by_digest_4_4;
9861 opti_type = OPTI_TYPE_ZERO_BYTE
9862 | OPTI_TYPE_PRECOMPUTE_INIT
9863 | OPTI_TYPE_PRECOMPUTE_MERKLE
9864 | OPTI_TYPE_EARLY_SKIP;
9865 dgst_pos0 = 0;
9866 dgst_pos1 = 3;
9867 dgst_pos2 = 2;
9868 dgst_pos3 = 1;
9869 break;
9870
9871 case 11200: hash_type = HASH_TYPE_SHA1;
9872 salt_type = SALT_TYPE_EMBEDDED;
9873 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9874 opts_type = OPTS_TYPE_PT_GENERATE_BE
9875 | OPTS_TYPE_PT_ADD80
9876 | OPTS_TYPE_ST_HEX;
9877 kern_type = KERN_TYPE_MYSQL_AUTH;
9878 dgst_size = DGST_SIZE_4_5;
9879 parse_func = mysql_auth_parse_hash;
9880 sort_by_digest = sort_by_digest_4_5;
9881 opti_type = OPTI_TYPE_ZERO_BYTE
9882 | OPTI_TYPE_EARLY_SKIP;
9883 dgst_pos0 = 3;
9884 dgst_pos1 = 4;
9885 dgst_pos2 = 2;
9886 dgst_pos3 = 1;
9887 break;
9888
9889 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9890 salt_type = SALT_TYPE_EMBEDDED;
9891 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9892 opts_type = OPTS_TYPE_PT_GENERATE_LE
9893 | OPTS_TYPE_ST_HEX
9894 | OPTS_TYPE_ST_ADD80;
9895 kern_type = KERN_TYPE_BITCOIN_WALLET;
9896 dgst_size = DGST_SIZE_4_4;
9897 parse_func = bitcoin_wallet_parse_hash;
9898 sort_by_digest = sort_by_digest_4_4;
9899 opti_type = OPTI_TYPE_ZERO_BYTE;
9900 dgst_pos0 = 0;
9901 dgst_pos1 = 1;
9902 dgst_pos2 = 2;
9903 dgst_pos3 = 3;
9904 break;
9905
9906 case 11400: hash_type = HASH_TYPE_MD5;
9907 salt_type = SALT_TYPE_EMBEDDED;
9908 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9909 opts_type = OPTS_TYPE_PT_GENERATE_LE
9910 | OPTS_TYPE_PT_ADD80
9911 | OPTS_TYPE_HASH_COPY;
9912 kern_type = KERN_TYPE_SIP_AUTH;
9913 dgst_size = DGST_SIZE_4_4;
9914 parse_func = sip_auth_parse_hash;
9915 sort_by_digest = sort_by_digest_4_4;
9916 opti_type = OPTI_TYPE_ZERO_BYTE;
9917 dgst_pos0 = 0;
9918 dgst_pos1 = 3;
9919 dgst_pos2 = 2;
9920 dgst_pos3 = 1;
9921 break;
9922
9923 case 11500: hash_type = HASH_TYPE_CRC32;
9924 salt_type = SALT_TYPE_INTERN;
9925 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9926 opts_type = OPTS_TYPE_PT_GENERATE_LE
9927 | OPTS_TYPE_ST_GENERATE_LE
9928 | OPTS_TYPE_ST_HEX;
9929 kern_type = KERN_TYPE_CRC32;
9930 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9931 parse_func = crc32_parse_hash;
9932 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9933 opti_type = OPTI_TYPE_ZERO_BYTE;
9934 dgst_pos0 = 0;
9935 dgst_pos1 = 1;
9936 dgst_pos2 = 2;
9937 dgst_pos3 = 3;
9938 break;
9939
9940 case 11600: hash_type = HASH_TYPE_AES;
9941 salt_type = SALT_TYPE_EMBEDDED;
9942 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9943 opts_type = OPTS_TYPE_PT_GENERATE_LE
9944 | OPTS_TYPE_PT_NEVERCRACK;
9945 kern_type = KERN_TYPE_SEVEN_ZIP;
9946 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9947 parse_func = seven_zip_parse_hash;
9948 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9949 opti_type = OPTI_TYPE_ZERO_BYTE;
9950 dgst_pos0 = 0;
9951 dgst_pos1 = 1;
9952 dgst_pos2 = 2;
9953 dgst_pos3 = 3;
9954 break;
9955
9956 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9957 salt_type = SALT_TYPE_NONE;
9958 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9959 opts_type = OPTS_TYPE_PT_GENERATE_LE
9960 | OPTS_TYPE_PT_ADD01;
9961 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9962 dgst_size = DGST_SIZE_4_8;
9963 parse_func = gost2012sbog_256_parse_hash;
9964 sort_by_digest = sort_by_digest_4_8;
9965 opti_type = OPTI_TYPE_ZERO_BYTE;
9966 dgst_pos0 = 0;
9967 dgst_pos1 = 1;
9968 dgst_pos2 = 2;
9969 dgst_pos3 = 3;
9970 break;
9971
9972 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
9973 salt_type = SALT_TYPE_NONE;
9974 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9975 opts_type = OPTS_TYPE_PT_GENERATE_LE
9976 | OPTS_TYPE_PT_ADD01;
9977 kern_type = KERN_TYPE_GOST_2012SBOG_512;
9978 dgst_size = DGST_SIZE_4_16;
9979 parse_func = gost2012sbog_512_parse_hash;
9980 sort_by_digest = sort_by_digest_4_16;
9981 opti_type = OPTI_TYPE_ZERO_BYTE;
9982 dgst_pos0 = 0;
9983 dgst_pos1 = 1;
9984 dgst_pos2 = 2;
9985 dgst_pos3 = 3;
9986 break;
9987
9988 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
9989 salt_type = SALT_TYPE_EMBEDDED;
9990 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9991 opts_type = OPTS_TYPE_PT_GENERATE_LE
9992 | OPTS_TYPE_ST_BASE64
9993 | OPTS_TYPE_HASH_COPY;
9994 kern_type = KERN_TYPE_PBKDF2_MD5;
9995 dgst_size = DGST_SIZE_4_32;
9996 parse_func = pbkdf2_md5_parse_hash;
9997 sort_by_digest = sort_by_digest_4_32;
9998 opti_type = OPTI_TYPE_ZERO_BYTE;
9999 dgst_pos0 = 0;
10000 dgst_pos1 = 1;
10001 dgst_pos2 = 2;
10002 dgst_pos3 = 3;
10003 break;
10004
10005 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10006 salt_type = SALT_TYPE_EMBEDDED;
10007 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10008 opts_type = OPTS_TYPE_PT_GENERATE_LE
10009 | OPTS_TYPE_ST_BASE64
10010 | OPTS_TYPE_HASH_COPY;
10011 kern_type = KERN_TYPE_PBKDF2_SHA1;
10012 dgst_size = DGST_SIZE_4_32;
10013 parse_func = pbkdf2_sha1_parse_hash;
10014 sort_by_digest = sort_by_digest_4_32;
10015 opti_type = OPTI_TYPE_ZERO_BYTE;
10016 dgst_pos0 = 0;
10017 dgst_pos1 = 1;
10018 dgst_pos2 = 2;
10019 dgst_pos3 = 3;
10020 break;
10021
10022 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10023 salt_type = SALT_TYPE_EMBEDDED;
10024 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10025 opts_type = OPTS_TYPE_PT_GENERATE_LE
10026 | OPTS_TYPE_ST_BASE64
10027 | OPTS_TYPE_HASH_COPY;
10028 kern_type = KERN_TYPE_PBKDF2_SHA512;
10029 dgst_size = DGST_SIZE_8_16;
10030 parse_func = pbkdf2_sha512_parse_hash;
10031 sort_by_digest = sort_by_digest_8_16;
10032 opti_type = OPTI_TYPE_ZERO_BYTE
10033 | OPTI_TYPE_USES_BITS_64;
10034 dgst_pos0 = 0;
10035 dgst_pos1 = 1;
10036 dgst_pos2 = 2;
10037 dgst_pos3 = 3;
10038 break;
10039
10040 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10041 salt_type = SALT_TYPE_EMBEDDED;
10042 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10043 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10044 kern_type = KERN_TYPE_ECRYPTFS;
10045 dgst_size = DGST_SIZE_8_8;
10046 parse_func = ecryptfs_parse_hash;
10047 sort_by_digest = sort_by_digest_8_8;
10048 opti_type = OPTI_TYPE_ZERO_BYTE
10049 | OPTI_TYPE_USES_BITS_64;
10050 dgst_pos0 = 0;
10051 dgst_pos1 = 1;
10052 dgst_pos2 = 2;
10053 dgst_pos3 = 3;
10054 break;
10055
10056 case 12300: hash_type = HASH_TYPE_ORACLET;
10057 salt_type = SALT_TYPE_EMBEDDED;
10058 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10059 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10060 kern_type = KERN_TYPE_ORACLET;
10061 dgst_size = DGST_SIZE_8_16;
10062 parse_func = oraclet_parse_hash;
10063 sort_by_digest = sort_by_digest_8_16;
10064 opti_type = OPTI_TYPE_ZERO_BYTE
10065 | OPTI_TYPE_USES_BITS_64;
10066 dgst_pos0 = 0;
10067 dgst_pos1 = 1;
10068 dgst_pos2 = 2;
10069 dgst_pos3 = 3;
10070 break;
10071
10072 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10073 salt_type = SALT_TYPE_EMBEDDED;
10074 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10075 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10076 kern_type = KERN_TYPE_BSDICRYPT;
10077 dgst_size = DGST_SIZE_4_4;
10078 parse_func = bsdicrypt_parse_hash;
10079 sort_by_digest = sort_by_digest_4_4;
10080 opti_type = OPTI_TYPE_ZERO_BYTE
10081 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10082 dgst_pos0 = 0;
10083 dgst_pos1 = 1;
10084 dgst_pos2 = 2;
10085 dgst_pos3 = 3;
10086 break;
10087
10088 case 12500: hash_type = HASH_TYPE_RAR3HP;
10089 salt_type = SALT_TYPE_EMBEDDED;
10090 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10091 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10092 kern_type = KERN_TYPE_RAR3;
10093 dgst_size = DGST_SIZE_4_4;
10094 parse_func = rar3hp_parse_hash;
10095 sort_by_digest = sort_by_digest_4_4;
10096 opti_type = OPTI_TYPE_ZERO_BYTE;
10097 dgst_pos0 = 0;
10098 dgst_pos1 = 1;
10099 dgst_pos2 = 2;
10100 dgst_pos3 = 3;
10101 break;
10102
10103 case 12600: hash_type = HASH_TYPE_SHA256;
10104 salt_type = SALT_TYPE_INTERN;
10105 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10106 opts_type = OPTS_TYPE_PT_GENERATE_BE
10107 | OPTS_TYPE_PT_ADD80;
10108 kern_type = KERN_TYPE_CF10;
10109 dgst_size = DGST_SIZE_4_8;
10110 parse_func = cf10_parse_hash;
10111 sort_by_digest = sort_by_digest_4_8;
10112 opti_type = OPTI_TYPE_ZERO_BYTE
10113 | OPTI_TYPE_PRECOMPUTE_INIT
10114 | OPTI_TYPE_EARLY_SKIP
10115 | OPTI_TYPE_NOT_ITERATED;
10116 dgst_pos0 = 3;
10117 dgst_pos1 = 7;
10118 dgst_pos2 = 2;
10119 dgst_pos3 = 6;
10120 break;
10121
10122 case 12700: hash_type = HASH_TYPE_AES;
10123 salt_type = SALT_TYPE_EMBEDDED;
10124 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10125 opts_type = OPTS_TYPE_PT_GENERATE_LE
10126 | OPTS_TYPE_HASH_COPY;
10127 kern_type = KERN_TYPE_MYWALLET;
10128 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10129 parse_func = mywallet_parse_hash;
10130 sort_by_digest = sort_by_digest_4_5;
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 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10139 salt_type = SALT_TYPE_EMBEDDED;
10140 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10141 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10142 kern_type = KERN_TYPE_MS_DRSR;
10143 dgst_size = DGST_SIZE_4_8;
10144 parse_func = ms_drsr_parse_hash;
10145 sort_by_digest = sort_by_digest_4_8;
10146 opti_type = OPTI_TYPE_ZERO_BYTE;
10147 dgst_pos0 = 0;
10148 dgst_pos1 = 1;
10149 dgst_pos2 = 2;
10150 dgst_pos3 = 3;
10151 break;
10152
10153 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10154 salt_type = SALT_TYPE_EMBEDDED;
10155 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10156 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10157 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10158 dgst_size = DGST_SIZE_4_8;
10159 parse_func = androidfde_samsung_parse_hash;
10160 sort_by_digest = sort_by_digest_4_8;
10161 opti_type = OPTI_TYPE_ZERO_BYTE;
10162 dgst_pos0 = 0;
10163 dgst_pos1 = 1;
10164 dgst_pos2 = 2;
10165 dgst_pos3 = 3;
10166 break;
10167
10168 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10169 salt_type = SALT_TYPE_EMBEDDED;
10170 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10171 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10172 kern_type = KERN_TYPE_RAR5;
10173 dgst_size = DGST_SIZE_4_4;
10174 parse_func = rar5_parse_hash;
10175 sort_by_digest = sort_by_digest_4_4;
10176 opti_type = OPTI_TYPE_ZERO_BYTE;
10177 dgst_pos0 = 0;
10178 dgst_pos1 = 1;
10179 dgst_pos2 = 2;
10180 dgst_pos3 = 3;
10181 break;
10182
10183 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10184 salt_type = SALT_TYPE_EMBEDDED;
10185 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10186 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10187 kern_type = KERN_TYPE_KRB5TGS;
10188 dgst_size = DGST_SIZE_4_4;
10189 parse_func = krb5tgs_parse_hash;
10190 sort_by_digest = sort_by_digest_4_4;
10191 opti_type = OPTI_TYPE_ZERO_BYTE
10192 | OPTI_TYPE_NOT_ITERATED;
10193 dgst_pos0 = 0;
10194 dgst_pos1 = 1;
10195 dgst_pos2 = 2;
10196 dgst_pos3 = 3;
10197 break;
10198
10199 default: usage_mini_print (PROGNAME); return (-1);
10200 }
10201
10202 /**
10203 * parser
10204 */
10205
10206 data.parse_func = parse_func;
10207
10208 /**
10209 * misc stuff
10210 */
10211
10212 if (hex_salt)
10213 {
10214 if (salt_type == SALT_TYPE_INTERN)
10215 {
10216 opts_type |= OPTS_TYPE_ST_HEX;
10217 }
10218 else
10219 {
10220 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10221
10222 return (-1);
10223 }
10224 }
10225
10226 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10227 | (salt_type == SALT_TYPE_EXTERN)
10228 | (salt_type == SALT_TYPE_EMBEDDED)
10229 | (salt_type == SALT_TYPE_VIRTUAL));
10230
10231 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10232
10233 data.hash_type = hash_type;
10234 data.attack_mode = attack_mode;
10235 data.attack_kern = attack_kern;
10236 data.attack_exec = attack_exec;
10237 data.kern_type = kern_type;
10238 data.opts_type = opts_type;
10239 data.dgst_size = dgst_size;
10240 data.salt_type = salt_type;
10241 data.isSalted = isSalted;
10242 data.sort_by_digest = sort_by_digest;
10243 data.dgst_pos0 = dgst_pos0;
10244 data.dgst_pos1 = dgst_pos1;
10245 data.dgst_pos2 = dgst_pos2;
10246 data.dgst_pos3 = dgst_pos3;
10247
10248 esalt_size = 0;
10249
10250 switch (hash_mode)
10251 {
10252 case 2500: esalt_size = sizeof (wpa_t); break;
10253 case 5300: esalt_size = sizeof (ikepsk_t); break;
10254 case 5400: esalt_size = sizeof (ikepsk_t); break;
10255 case 5500: esalt_size = sizeof (netntlm_t); break;
10256 case 5600: esalt_size = sizeof (netntlm_t); break;
10257 case 6211: esalt_size = sizeof (tc_t); break;
10258 case 6212: esalt_size = sizeof (tc_t); break;
10259 case 6213: esalt_size = sizeof (tc_t); break;
10260 case 6221: esalt_size = sizeof (tc_t); break;
10261 case 6222: esalt_size = sizeof (tc_t); break;
10262 case 6223: esalt_size = sizeof (tc_t); break;
10263 case 6231: esalt_size = sizeof (tc_t); break;
10264 case 6232: esalt_size = sizeof (tc_t); break;
10265 case 6233: esalt_size = sizeof (tc_t); break;
10266 case 6241: esalt_size = sizeof (tc_t); break;
10267 case 6242: esalt_size = sizeof (tc_t); break;
10268 case 6243: esalt_size = sizeof (tc_t); break;
10269 case 6600: esalt_size = sizeof (agilekey_t); break;
10270 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10271 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10272 case 7300: esalt_size = sizeof (rakp_t); break;
10273 case 7500: esalt_size = sizeof (krb5pa_t); break;
10274 case 8200: esalt_size = sizeof (cloudkey_t); break;
10275 case 8800: esalt_size = sizeof (androidfde_t); break;
10276 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10277 case 9400: esalt_size = sizeof (office2007_t); break;
10278 case 9500: esalt_size = sizeof (office2010_t); break;
10279 case 9600: esalt_size = sizeof (office2013_t); break;
10280 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10281 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10282 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10283 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10284 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10285 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10286 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10287 case 10200: esalt_size = sizeof (cram_md5_t); break;
10288 case 10400: esalt_size = sizeof (pdf_t); break;
10289 case 10410: esalt_size = sizeof (pdf_t); break;
10290 case 10420: esalt_size = sizeof (pdf_t); break;
10291 case 10500: esalt_size = sizeof (pdf_t); break;
10292 case 10600: esalt_size = sizeof (pdf_t); break;
10293 case 10700: esalt_size = sizeof (pdf_t); break;
10294 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10295 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10296 case 11400: esalt_size = sizeof (sip_t); break;
10297 case 11600: esalt_size = sizeof (seven_zip_t); break;
10298 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10299 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10300 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10301 case 13000: esalt_size = sizeof (rar5_t); break;
10302 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10303 }
10304
10305 data.esalt_size = esalt_size;
10306
10307 /**
10308 * choose dictionary parser
10309 */
10310
10311 if (hash_type == HASH_TYPE_LM)
10312 {
10313 get_next_word_func = get_next_word_lm;
10314 }
10315 else if (opts_type & OPTS_TYPE_PT_UPPER)
10316 {
10317 get_next_word_func = get_next_word_uc;
10318 }
10319 else
10320 {
10321 get_next_word_func = get_next_word_std;
10322 }
10323
10324 /**
10325 * dictstat
10326 */
10327
10328 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10329
10330 #ifdef _POSIX
10331 size_t dictstat_nmemb = 0;
10332 #endif
10333
10334 #ifdef _WIN
10335 uint dictstat_nmemb = 0;
10336 #endif
10337
10338 char dictstat[256] = { 0 };
10339
10340 FILE *dictstat_fp = NULL;
10341
10342 if (keyspace == 0)
10343 {
10344 snprintf (dictstat, sizeof (dictstat) - 1, "%s/hashcat.dictstat", profile_dir);
10345
10346 dictstat_fp = fopen (dictstat, "rb");
10347
10348 if (dictstat_fp)
10349 {
10350 #ifdef _POSIX
10351 struct stat tmpstat;
10352
10353 fstat (fileno (dictstat_fp), &tmpstat);
10354 #endif
10355
10356 #ifdef _WIN
10357 struct stat64 tmpstat;
10358
10359 _fstat64 (fileno (dictstat_fp), &tmpstat);
10360 #endif
10361
10362 if (tmpstat.st_mtime < COMPTIME)
10363 {
10364 /* with v0.15 the format changed so we have to ensure user is using a good version
10365 since there is no version-header in the dictstat file */
10366
10367 fclose (dictstat_fp);
10368
10369 unlink (dictstat);
10370 }
10371 else
10372 {
10373 while (!feof (dictstat_fp))
10374 {
10375 dictstat_t d;
10376
10377 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10378
10379 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10380
10381 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10382 {
10383 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10384
10385 return -1;
10386 }
10387 }
10388
10389 fclose (dictstat_fp);
10390 }
10391 }
10392 }
10393
10394 /**
10395 * potfile
10396 */
10397
10398 char potfile[256] = { 0 };
10399
10400 snprintf (potfile, sizeof (potfile) - 1, "%s/%s.pot", session_dir, session);
10401
10402 data.pot_fp = NULL;
10403
10404 FILE *out_fp = NULL;
10405 FILE *pot_fp = NULL;
10406
10407 if (show == 1 || left == 1)
10408 {
10409 pot_fp = fopen (potfile, "rb");
10410
10411 if (pot_fp == NULL)
10412 {
10413 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10414
10415 return (-1);
10416 }
10417
10418 if (outfile != NULL)
10419 {
10420 if ((out_fp = fopen (outfile, "ab")) == NULL)
10421 {
10422 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10423
10424 fclose (pot_fp);
10425
10426 return (-1);
10427 }
10428 }
10429 else
10430 {
10431 out_fp = stdout;
10432 }
10433 }
10434 else
10435 {
10436 if (potfile_disable == 0)
10437 {
10438 pot_fp = fopen (potfile, "ab");
10439
10440 if (pot_fp == NULL)
10441 {
10442 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10443
10444 return (-1);
10445 }
10446
10447 data.pot_fp = pot_fp;
10448 }
10449 }
10450
10451 pot_t *pot = NULL;
10452
10453 uint pot_cnt = 0;
10454 uint pot_avail = 0;
10455
10456 if (show == 1 || left == 1)
10457 {
10458 SUPPRESS_OUTPUT = 1;
10459
10460 pot_avail = count_lines (pot_fp);
10461
10462 rewind (pot_fp);
10463
10464 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10465
10466 uint pot_hashes_avail = 0;
10467
10468 uint line_num = 0;
10469
10470 while (!feof (pot_fp))
10471 {
10472 line_num++;
10473
10474 char line_buf[BUFSIZ] = { 0 };
10475
10476 int line_len = fgetl (pot_fp, line_buf);
10477
10478 if (line_len == 0) continue;
10479
10480 char *plain_buf = line_buf + line_len;
10481
10482 pot_t *pot_ptr = &pot[pot_cnt];
10483
10484 hash_t *hashes_buf = &pot_ptr->hash;
10485
10486 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10487 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10488
10489 if (pot_cnt == pot_hashes_avail)
10490 {
10491 uint pos = 0;
10492
10493 for (pos = 0; pos < INCR_POT; pos++)
10494 {
10495 if ((pot_cnt + pos) >= pot_avail) break;
10496
10497 pot_t *tmp_pot = &pot[pot_cnt + pos];
10498
10499 hash_t *tmp_hash = &tmp_pot->hash;
10500
10501 tmp_hash->digest = mymalloc (dgst_size);
10502
10503 if (isSalted)
10504 {
10505 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10506 }
10507
10508 if (esalt_size)
10509 {
10510 tmp_hash->esalt = mymalloc (esalt_size);
10511 }
10512
10513 pot_hashes_avail++;
10514 }
10515 }
10516
10517 int plain_len = 0;
10518
10519 int parser_status;
10520
10521 int iter = MAX_CUT_TRIES;
10522
10523 do
10524 {
10525 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10526 {
10527 if (line_buf[i] == ':')
10528 {
10529 line_len--;
10530
10531 break;
10532 }
10533 }
10534
10535 if (data.hash_mode != 2500)
10536 {
10537 parser_status = parse_func (line_buf, line_len, hashes_buf);
10538 }
10539 else
10540 {
10541 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10542
10543 if (line_len > max_salt_size)
10544 {
10545 parser_status = PARSER_GLOBAL_LENGTH;
10546 }
10547 else
10548 {
10549 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10550
10551 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10552
10553 hashes_buf->salt->salt_len = line_len;
10554
10555 parser_status = PARSER_OK;
10556 }
10557 }
10558
10559 // if NOT parsed without error, we add the ":" to the plain
10560
10561 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10562 {
10563 plain_len++;
10564 plain_buf--;
10565 }
10566
10567 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10568
10569 if (parser_status < PARSER_GLOBAL_ZERO)
10570 {
10571 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10572
10573 continue;
10574 }
10575
10576 if (plain_len >= 255) continue;
10577
10578 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10579
10580 pot_ptr->plain_len = plain_len;
10581
10582 pot_cnt++;
10583 }
10584
10585 fclose (pot_fp);
10586
10587 SUPPRESS_OUTPUT = 0;
10588
10589 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10590 }
10591
10592 /**
10593 * word len
10594 */
10595
10596 uint pw_min = PW_MIN;
10597 uint pw_max = PW_MAX;
10598
10599 switch (hash_mode)
10600 {
10601 case 400: if (pw_max > 40) pw_max = 40;
10602 break;
10603 case 500: if (pw_max > 16) pw_max = 16;
10604 break;
10605 case 1500: if (pw_max > 8) pw_max = 8;
10606 break;
10607 case 1600: if (pw_max > 16) pw_max = 16;
10608 break;
10609 case 1800: if (pw_max > 16) pw_max = 16;
10610 break;
10611 case 2100: if (pw_max > 16) pw_max = 16;
10612 break;
10613 case 2500: if (pw_min < 8) pw_min = 8;
10614 break;
10615 case 3000: if (pw_max > 7) pw_max = 7;
10616 break;
10617 case 5200: if (pw_max > 24) pw_max = 24;
10618 break;
10619 case 5800: if (pw_max > 16) pw_max = 16;
10620 break;
10621 case 6300: if (pw_max > 16) pw_max = 16;
10622 break;
10623 case 7400: if (pw_max > 16) pw_max = 16;
10624 break;
10625 case 7900: if (pw_max > 48) pw_max = 48;
10626 break;
10627 case 8500: if (pw_max > 8) pw_max = 8;
10628 break;
10629 case 8600: if (pw_max > 16) pw_max = 16;
10630 break;
10631 case 9710: pw_min = 5;
10632 pw_max = 5;
10633 break;
10634 case 9810: pw_min = 5;
10635 pw_max = 5;
10636 break;
10637 case 10410: pw_min = 5;
10638 pw_max = 5;
10639 break;
10640 case 10300: if (pw_max < 3) pw_min = 3;
10641 if (pw_max > 40) pw_max = 40;
10642 break;
10643 case 10500: if (pw_max < 3) pw_min = 3;
10644 if (pw_max > 40) pw_max = 40;
10645 break;
10646 case 10700: if (pw_max > 16) pw_max = 16;
10647 break;
10648 case 11300: if (pw_max > 40) pw_max = 40;
10649 break;
10650 case 12500: if (pw_max > 20) pw_max = 20;
10651 break;
10652 case 12800: if (pw_max > 24) pw_max = 24;
10653 break;
10654 }
10655
10656 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10657 {
10658 switch (attack_kern)
10659 {
10660 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10661 break;
10662 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10663 break;
10664 }
10665 }
10666
10667 /**
10668 * charsets : keep them together for more easy maintainnce
10669 */
10670
10671 cs_t mp_sys[6] = { { { 0 }, 0 } };
10672 cs_t mp_usr[4] = { { { 0 }, 0 } };
10673
10674 mp_setup_sys (mp_sys);
10675
10676 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10677 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10678 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10679 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10680
10681 /**
10682 * load hashes, part I: find input mode, count hashes
10683 */
10684
10685 uint hashlist_mode = 0;
10686 uint hashlist_format = HLFMT_HASHCAT;
10687
10688 uint hashes_avail = 0;
10689
10690 if (benchmark == 0)
10691 {
10692 struct stat f;
10693
10694 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10695
10696 if ((hash_mode == 2500) ||
10697 (hash_mode == 5200) ||
10698 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10699 (hash_mode == 9000))
10700 {
10701 hashlist_mode = HL_MODE_ARG;
10702
10703 char *hashfile = myargv[optind];
10704
10705 data.hashfile = hashfile;
10706
10707 logfile_top_var_string ("target", hashfile);
10708 }
10709
10710 if (hashlist_mode == HL_MODE_ARG)
10711 {
10712 if (hash_mode == 2500)
10713 {
10714 struct stat st;
10715
10716 if (stat (data.hashfile, &st) == -1)
10717 {
10718 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10719
10720 return (-1);
10721 }
10722
10723 hashes_avail = st.st_size / sizeof (hccap_t);
10724 }
10725 else
10726 {
10727 hashes_avail = 1;
10728 }
10729 }
10730 else if (hashlist_mode == HL_MODE_FILE)
10731 {
10732 char *hashfile = myargv[optind];
10733
10734 data.hashfile = hashfile;
10735
10736 logfile_top_var_string ("target", hashfile);
10737
10738 FILE *fp = NULL;
10739
10740 if ((fp = fopen (hashfile, "rb")) == NULL)
10741 {
10742 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10743
10744 return (-1);
10745 }
10746
10747 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10748
10749 hashes_avail = count_lines (fp);
10750
10751 rewind (fp);
10752
10753 if (hashes_avail == 0)
10754 {
10755 log_error ("ERROR: hashfile is empty or corrupt");
10756
10757 fclose (fp);
10758
10759 return (-1);
10760 }
10761
10762 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10763
10764 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10765 {
10766 log_error ("ERROR: remove not supported in native hashfile-format mode");
10767
10768 fclose (fp);
10769
10770 return (-1);
10771 }
10772
10773 fclose (fp);
10774 }
10775 }
10776 else
10777 {
10778 hashlist_mode = HL_MODE_ARG;
10779
10780 hashes_avail = 1;
10781 }
10782
10783 if (hash_mode == 3000) hashes_avail *= 2;
10784
10785 data.hashlist_mode = hashlist_mode;
10786 data.hashlist_format = hashlist_format;
10787
10788 logfile_top_uint (hashlist_mode);
10789 logfile_top_uint (hashlist_format);
10790
10791 /**
10792 * load hashes, part II: allocate required memory, set pointers
10793 */
10794
10795 hash_t *hashes_buf = NULL;
10796 void *digests_buf = NULL;
10797 salt_t *salts_buf = NULL;
10798 void *esalts_buf = NULL;
10799
10800 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10801
10802 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10803
10804 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10805 {
10806 u32 hash_pos;
10807
10808 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10809 {
10810 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10811
10812 hashes_buf[hash_pos].hash_info = hash_info;
10813
10814 if (username && (remove || show || left))
10815 {
10816 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10817 }
10818
10819 if (benchmark)
10820 {
10821 hash_info->orighash = (char *) mymalloc (256);
10822 }
10823 }
10824 }
10825
10826 if (isSalted)
10827 {
10828 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10829
10830 if (esalt_size)
10831 {
10832 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10833 }
10834 }
10835 else
10836 {
10837 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10838 }
10839
10840 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10841 {
10842 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10843
10844 if (isSalted)
10845 {
10846 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10847
10848 if (esalt_size)
10849 {
10850 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10851 }
10852 }
10853 else
10854 {
10855 hashes_buf[hash_pos].salt = &salts_buf[0];
10856 }
10857 }
10858
10859 /**
10860 * load hashes, part III: parse hashes or generate them if benchmark
10861 */
10862
10863 uint hashes_cnt = 0;
10864
10865 if (benchmark == 0)
10866 {
10867 if (keyspace == 1)
10868 {
10869 // useless to read hash file for keyspace, cheat a little bit w/ optind
10870 }
10871 else if (hashes_avail == 0)
10872 {
10873 }
10874 else if (hashlist_mode == HL_MODE_ARG)
10875 {
10876 char *input_buf = myargv[optind];
10877
10878 uint input_len = strlen (input_buf);
10879
10880 logfile_top_var_string ("target", input_buf);
10881
10882 char *hash_buf = NULL;
10883 int hash_len = 0;
10884
10885 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10886
10887 if (hash_len)
10888 {
10889 if (opts_type & OPTS_TYPE_HASH_COPY)
10890 {
10891 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10892
10893 hash_info_tmp->orighash = mystrdup (hash_buf);
10894 }
10895
10896 if (isSalted)
10897 {
10898 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
10899 }
10900
10901 int parser_status = PARSER_OK;
10902
10903 if (hash_mode == 2500)
10904 {
10905 if (hash_len == 0)
10906 {
10907 log_error ("ERROR: hccap file not specified");
10908
10909 return (-1);
10910 }
10911
10912 hashlist_mode = HL_MODE_FILE;
10913
10914 data.hashlist_mode = hashlist_mode;
10915
10916 FILE *fp = fopen (hash_buf, "rb");
10917
10918 if (fp == NULL)
10919 {
10920 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
10921
10922 return (-1);
10923 }
10924
10925 if (hashes_avail < 1)
10926 {
10927 log_error ("ERROR: hccap file is empty or corrupt");
10928
10929 fclose (fp);
10930
10931 return (-1);
10932 }
10933
10934 uint hccap_size = sizeof (hccap_t);
10935
10936 char *in = (char *) mymalloc (hccap_size);
10937
10938 while (!feof (fp))
10939 {
10940 int n = fread (in, hccap_size, 1, fp);
10941
10942 if (n != 1)
10943 {
10944 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
10945
10946 break;
10947 }
10948
10949 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
10950
10951 if (parser_status != PARSER_OK)
10952 {
10953 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
10954
10955 continue;
10956 }
10957
10958 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
10959
10960 if ((show == 1) || (left == 1))
10961 {
10962 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
10963
10964 char *salt_ptr = (char *) tmp_salt->salt_buf;
10965
10966 int cur_pos = tmp_salt->salt_len;
10967 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10968
10969 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
10970
10971 u8 *pke_ptr = (u8 *) wpa->pke;
10972
10973 // do the appending task
10974
10975 snprintf (salt_ptr + cur_pos,
10976 rem_len,
10977 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
10978 pke_ptr[20], pke_ptr[27], pke_ptr[26], pke_ptr[25], pke_ptr[24], pke_ptr[31], // MAC1
10979 pke_ptr[30], pke_ptr[29], pke_ptr[28], pke_ptr[35], pke_ptr[34], pke_ptr[33]); // MAC2
10980
10981
10982 // memset () the remaining part of the salt
10983
10984 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
10985 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10986
10987 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
10988
10989 tmp_salt->salt_len += 1 + 12 + 1 + 12;
10990 }
10991
10992 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);
10993 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);
10994
10995 hashes_cnt++;
10996 }
10997
10998 fclose (fp);
10999
11000 myfree (in);
11001 }
11002 else if (hash_mode == 3000)
11003 {
11004 if (hash_len == 32)
11005 {
11006 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11007
11008 hash_t *lm_hash_left = NULL;
11009
11010 if (parser_status == PARSER_OK)
11011 {
11012 lm_hash_left = &hashes_buf[hashes_cnt];
11013
11014 hashes_cnt++;
11015 }
11016 else
11017 {
11018 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11019 }
11020
11021 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11022
11023 hash_t *lm_hash_right = NULL;
11024
11025 if (parser_status == PARSER_OK)
11026 {
11027 lm_hash_right = &hashes_buf[hashes_cnt];
11028
11029 hashes_cnt++;
11030 }
11031 else
11032 {
11033 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11034 }
11035
11036 // show / left
11037
11038 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11039 {
11040 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);
11041 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);
11042 }
11043 }
11044 else
11045 {
11046 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11047
11048 if (parser_status == PARSER_OK)
11049 {
11050 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11051 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11052 }
11053
11054 if (parser_status == PARSER_OK)
11055 {
11056 hashes_cnt++;
11057 }
11058 else
11059 {
11060 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11061 }
11062 }
11063 }
11064 else
11065 {
11066 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11067
11068 if (parser_status == PARSER_OK)
11069 {
11070 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11071 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11072 }
11073
11074 if (parser_status == PARSER_OK)
11075 {
11076 hashes_cnt++;
11077 }
11078 else
11079 {
11080 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11081 }
11082 }
11083 }
11084 }
11085 else if (hashlist_mode == HL_MODE_FILE)
11086 {
11087 char *hashfile = data.hashfile;
11088
11089 FILE *fp;
11090
11091 if ((fp = fopen (hashfile, "rb")) == NULL)
11092 {
11093 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11094
11095 return (-1);
11096 }
11097
11098 uint line_num = 0;
11099
11100 while (!feof (fp))
11101 {
11102 line_num++;
11103
11104 char line_buf[BUFSIZ] = { 0 };
11105
11106 int line_len = fgetl (fp, line_buf);
11107
11108 if (line_len == 0) continue;
11109
11110 char *hash_buf = NULL;
11111 int hash_len = 0;
11112
11113 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11114
11115 if (username)
11116 {
11117 char *user_buf = NULL;
11118 int user_len = 0;
11119
11120 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11121
11122 if (remove || show)
11123 {
11124 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11125
11126 *user = (user_t *) mymalloc (sizeof (user_t));
11127
11128 user_t *user_ptr = *user;
11129
11130 if (user_buf != NULL)
11131 {
11132 user_ptr->user_name = mystrdup (user_buf);
11133 }
11134 else
11135 {
11136 user_ptr->user_name = mystrdup ("");
11137 }
11138
11139 user_ptr->user_len = user_len;
11140 }
11141 }
11142
11143 if (opts_type & OPTS_TYPE_HASH_COPY)
11144 {
11145 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11146
11147 hash_info_tmp->orighash = mystrdup (hash_buf);
11148 }
11149
11150 if (isSalted)
11151 {
11152 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11153 }
11154
11155 if (hash_mode == 3000)
11156 {
11157 if (hash_len == 32)
11158 {
11159 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11160
11161 if (parser_status < PARSER_GLOBAL_ZERO)
11162 {
11163 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11164
11165 continue;
11166 }
11167
11168 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11169
11170 hashes_cnt++;
11171
11172 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11173
11174 if (parser_status < PARSER_GLOBAL_ZERO)
11175 {
11176 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11177
11178 continue;
11179 }
11180
11181 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11182
11183 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);
11184
11185 hashes_cnt++;
11186
11187 // show / left
11188
11189 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);
11190 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);
11191 }
11192 else
11193 {
11194 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11195
11196 if (parser_status < PARSER_GLOBAL_ZERO)
11197 {
11198 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11199
11200 continue;
11201 }
11202
11203 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);
11204
11205 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11206 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11207
11208 hashes_cnt++;
11209 }
11210 }
11211 else
11212 {
11213 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11214
11215 if (parser_status < PARSER_GLOBAL_ZERO)
11216 {
11217 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11218
11219 continue;
11220 }
11221
11222 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);
11223
11224 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11225 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11226
11227 hashes_cnt++;
11228 }
11229 }
11230
11231 fclose (fp);
11232
11233 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11234
11235 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11236 }
11237 }
11238 else
11239 {
11240 if (isSalted)
11241 {
11242 hashes_buf[0].salt->salt_len = 8;
11243
11244 // special salt handling
11245
11246 switch (hash_mode)
11247 {
11248 case 1500: hashes_buf[0].salt->salt_len = 2;
11249 break;
11250 case 1731: hashes_buf[0].salt->salt_len = 4;
11251 break;
11252 case 2410: hashes_buf[0].salt->salt_len = 4;
11253 break;
11254 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11255 break;
11256 case 3100: hashes_buf[0].salt->salt_len = 1;
11257 break;
11258 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11259 break;
11260 case 5800: hashes_buf[0].salt->salt_len = 16;
11261 break;
11262 case 6800: hashes_buf[0].salt->salt_len = 32;
11263 break;
11264 case 8400: hashes_buf[0].salt->salt_len = 40;
11265 break;
11266 case 8800: hashes_buf[0].salt->salt_len = 16;
11267 break;
11268 case 8900: hashes_buf[0].salt->salt_len = 16;
11269 hashes_buf[0].salt->scrypt_N = 1024;
11270 hashes_buf[0].salt->scrypt_r = 1;
11271 hashes_buf[0].salt->scrypt_p = 1;
11272 break;
11273 case 9100: hashes_buf[0].salt->salt_len = 16;
11274 break;
11275 case 9300: hashes_buf[0].salt->salt_len = 14;
11276 hashes_buf[0].salt->scrypt_N = 16384;
11277 hashes_buf[0].salt->scrypt_r = 1;
11278 hashes_buf[0].salt->scrypt_p = 1;
11279 break;
11280 case 9400: hashes_buf[0].salt->salt_len = 16;
11281 break;
11282 case 9500: hashes_buf[0].salt->salt_len = 16;
11283 break;
11284 case 9600: hashes_buf[0].salt->salt_len = 16;
11285 break;
11286 case 9700: hashes_buf[0].salt->salt_len = 16;
11287 break;
11288 case 9710: hashes_buf[0].salt->salt_len = 16;
11289 break;
11290 case 9720: hashes_buf[0].salt->salt_len = 16;
11291 break;
11292 case 9800: hashes_buf[0].salt->salt_len = 16;
11293 break;
11294 case 9810: hashes_buf[0].salt->salt_len = 16;
11295 break;
11296 case 9820: hashes_buf[0].salt->salt_len = 16;
11297 break;
11298 case 10300: hashes_buf[0].salt->salt_len = 12;
11299 break;
11300 case 11500: hashes_buf[0].salt->salt_len = 4;
11301 break;
11302 case 11600: hashes_buf[0].salt->salt_len = 4;
11303 break;
11304 case 12400: hashes_buf[0].salt->salt_len = 4;
11305 break;
11306 case 12500: hashes_buf[0].salt->salt_len = 8;
11307 break;
11308 case 12600: hashes_buf[0].salt->salt_len = 64;
11309 break;
11310 }
11311
11312 // special esalt handling
11313
11314 switch (hash_mode)
11315 {
11316 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11317 break;
11318 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11319 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11320 break;
11321 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11322 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11323 break;
11324 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11325 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11326 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11327 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11328 break;
11329 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11330 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11331 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11332 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11333 break;
11334 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11335 break;
11336 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11337 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11338 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11339 break;
11340 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11341 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11342 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11343 break;
11344 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11345 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11346 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11347 break;
11348 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11349 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11350 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11351 break;
11352 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11353 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11354 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11355 break;
11356 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11357 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11358 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11359 break;
11360 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11361 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11362 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11363 break;
11364 }
11365 }
11366
11367 // set hashfile
11368
11369 switch (hash_mode)
11370 {
11371 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11372 break;
11373 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11374 break;
11375 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11376 break;
11377 case 6211: data.hashfile = mystrdup ("hashcat.tc");
11378 break;
11379 case 6212: data.hashfile = mystrdup ("hashcat.tc");
11380 break;
11381 case 6213: data.hashfile = mystrdup ("hashcat.tc");
11382 break;
11383 case 6221: data.hashfile = mystrdup ("hashcat.tc");
11384 break;
11385 case 6222: data.hashfile = mystrdup ("hashcat.tc");
11386 break;
11387 case 6223: data.hashfile = mystrdup ("hashcat.tc");
11388 break;
11389 case 6231: data.hashfile = mystrdup ("hashcat.tc");
11390 break;
11391 case 6232: data.hashfile = mystrdup ("hashcat.tc");
11392 break;
11393 case 6233: data.hashfile = mystrdup ("hashcat.tc");
11394 break;
11395 case 6241: data.hashfile = mystrdup ("hashcat.tc");
11396 break;
11397 case 6242: data.hashfile = mystrdup ("hashcat.tc");
11398 break;
11399 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11400 break;
11401 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11402 break;
11403 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11404 break;
11405 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11406 break;
11407 }
11408
11409 // set default iterations
11410
11411 switch (hash_mode)
11412 {
11413 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11414 break;
11415 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11416 break;
11417 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11418 break;
11419 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11420 break;
11421 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11422 break;
11423 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11424 break;
11425 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11426 break;
11427 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11428 break;
11429 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11430 break;
11431 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11432 break;
11433 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11434 break;
11435 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11436 break;
11437 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11438 break;
11439 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11440 break;
11441 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11442 break;
11443 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11444 break;
11445 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11446 break;
11447 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11448 break;
11449 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11450 break;
11451 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11452 break;
11453 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11454 break;
11455 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11456 break;
11457 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11458 break;
11459 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11460 break;
11461 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11462 break;
11463 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11464 break;
11465 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11466 break;
11467 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11468 break;
11469 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11470 break;
11471 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11472 break;
11473 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11474 break;
11475 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11476 break;
11477 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11478 break;
11479 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11480 break;
11481 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11482 break;
11483 case 8900: hashes_buf[0].salt->salt_iter = 1;
11484 break;
11485 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11486 break;
11487 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11488 break;
11489 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11490 break;
11491 case 9300: hashes_buf[0].salt->salt_iter = 1;
11492 break;
11493 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11494 break;
11495 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11496 break;
11497 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11498 break;
11499 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11500 break;
11501 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11502 break;
11503 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11504 break;
11505 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11506 break;
11507 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11508 break;
11509 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11510 break;
11511 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11512 break;
11513 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11514 break;
11515 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11516 break;
11517 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11518 break;
11519 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11520 break;
11521 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11522 break;
11523 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11524 break;
11525 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11526 break;
11527 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11528 break;
11529 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11530 break;
11531 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11532 break;
11533 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11534 break;
11535 }
11536
11537 hashes_cnt = 1;
11538 }
11539
11540 if (show == 1 || left == 1)
11541 {
11542 for (uint i = 0; i < pot_cnt; i++)
11543 {
11544 pot_t *pot_ptr = &pot[i];
11545
11546 hash_t *hashes_buf = &pot_ptr->hash;
11547
11548 local_free (hashes_buf->digest);
11549
11550 if (isSalted)
11551 {
11552 local_free (hashes_buf->salt);
11553 }
11554 }
11555
11556 local_free (pot);
11557
11558 if (data.quiet == 0) log_info_nn ("");
11559
11560 return (0);
11561 }
11562
11563 if (keyspace == 0)
11564 {
11565 if (hashes_cnt == 0)
11566 {
11567 log_error ("ERROR: No hashes loaded");
11568
11569 return (-1);
11570 }
11571 }
11572
11573 /**
11574 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11575 */
11576
11577 if (data.outfile != NULL)
11578 {
11579 if (data.hashfile != NULL)
11580 {
11581 #ifdef _POSIX
11582 struct stat tmpstat_outfile;
11583 struct stat tmpstat_hashfile;
11584 #endif
11585
11586 #ifdef _WIN
11587 struct stat64 tmpstat_outfile;
11588 struct stat64 tmpstat_hashfile;
11589 #endif
11590
11591 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11592
11593 if (tmp_outfile_fp)
11594 {
11595 #ifdef _POSIX
11596 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11597 #endif
11598
11599 #ifdef _WIN
11600 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11601 #endif
11602
11603 fclose (tmp_outfile_fp);
11604 }
11605
11606 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11607
11608 if (tmp_hashfile_fp)
11609 {
11610 #ifdef _POSIX
11611 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11612 #endif
11613
11614 #ifdef _WIN
11615 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11616 #endif
11617
11618 fclose (tmp_hashfile_fp);
11619 }
11620
11621 if (tmp_outfile_fp && tmp_outfile_fp)
11622 {
11623 tmpstat_outfile.st_mode = 0;
11624 tmpstat_outfile.st_nlink = 0;
11625 tmpstat_outfile.st_uid = 0;
11626 tmpstat_outfile.st_gid = 0;
11627 tmpstat_outfile.st_rdev = 0;
11628 tmpstat_outfile.st_atime = 0;
11629
11630 tmpstat_hashfile.st_mode = 0;
11631 tmpstat_hashfile.st_nlink = 0;
11632 tmpstat_hashfile.st_uid = 0;
11633 tmpstat_hashfile.st_gid = 0;
11634 tmpstat_hashfile.st_rdev = 0;
11635 tmpstat_hashfile.st_atime = 0;
11636
11637 #ifdef _POSIX
11638 tmpstat_outfile.st_blksize = 0;
11639 tmpstat_outfile.st_blocks = 0;
11640
11641 tmpstat_hashfile.st_blksize = 0;
11642 tmpstat_hashfile.st_blocks = 0;
11643 #endif
11644
11645 #ifdef _POSIX
11646 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11647 {
11648 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11649
11650 return (-1);
11651 }
11652 #endif
11653
11654 #ifdef _WIN
11655 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11656 {
11657 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11658
11659 return (-1);
11660 }
11661 #endif
11662 }
11663 }
11664 }
11665
11666 /**
11667 * Remove duplicates
11668 */
11669
11670 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11671
11672 if (isSalted)
11673 {
11674 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11675 }
11676 else
11677 {
11678 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11679 }
11680
11681 uint hashes_cnt_orig = hashes_cnt;
11682
11683 hashes_cnt = 1;
11684
11685 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11686 {
11687 if (isSalted)
11688 {
11689 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11690 {
11691 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11692 }
11693 }
11694 else
11695 {
11696 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11697 }
11698
11699 if (hashes_pos > hashes_cnt)
11700 {
11701 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11702 }
11703
11704 hashes_cnt++;
11705 }
11706
11707 /**
11708 * Potfile removes
11709 */
11710
11711 uint potfile_remove_cracks = 0;
11712
11713 if (potfile_disable == 0)
11714 {
11715 hash_t hash_buf;
11716
11717 hash_buf.digest = mymalloc (dgst_size);
11718 hash_buf.salt = NULL;
11719 hash_buf.esalt = NULL;
11720 hash_buf.hash_info = NULL;
11721 hash_buf.cracked = 0;
11722
11723 if (isSalted)
11724 {
11725 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11726 }
11727
11728 if (esalt_size)
11729 {
11730 hash_buf.esalt = mymalloc (esalt_size);
11731 }
11732
11733 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11734
11735 // no solution for these special hash types (for instane because they use hashfile in output etc)
11736 if ((hash_mode != 5200) &&
11737 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11738 (hash_mode != 9000))
11739 {
11740 FILE *fp = fopen (potfile, "rb");
11741
11742 if (fp != NULL)
11743 {
11744 while (!feof (fp))
11745 {
11746 char line_buf[BUFSIZ] = { 0 };
11747
11748 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
11749
11750 if (ptr == NULL) break;
11751
11752 int line_len = strlen (line_buf);
11753
11754 if (line_len == 0) continue;
11755
11756 int iter = MAX_CUT_TRIES;
11757
11758 for (int i = line_len - 1; i && iter; i--, line_len--)
11759 {
11760 if (line_buf[i] != ':') continue;
11761
11762 if (isSalted)
11763 {
11764 memset (hash_buf.salt, 0, sizeof (salt_t));
11765 }
11766
11767 hash_t *found = NULL;
11768
11769 if (hash_mode == 6800)
11770 {
11771 if (i < 64) // 64 = 16 * uint in salt_buf[]
11772 {
11773 // manipulate salt_buf
11774 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11775
11776 hash_buf.salt->salt_len = i;
11777
11778 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11779 }
11780 }
11781 else if (hash_mode == 2500)
11782 {
11783 if (i < 64) // 64 = 16 * uint in salt_buf[]
11784 {
11785 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11786 // manipulate salt_buf
11787
11788 // to be safe work with a copy (because of line_len loop, i etc)
11789
11790 char line_buf_cpy[BUFSIZ] = { 0 };
11791
11792 memcpy (line_buf_cpy, line_buf, i);
11793
11794 char *mac2_pos = strrchr (line_buf_cpy, ':');
11795
11796 if (mac2_pos == NULL) continue;
11797
11798 mac2_pos[0] = 0;
11799 mac2_pos++;
11800
11801 if (strlen (mac2_pos) != 12) continue;
11802
11803 char *mac1_pos = strrchr (line_buf_cpy, ':');
11804
11805 if (mac1_pos == NULL) continue;
11806
11807 mac1_pos[0] = 0;
11808 mac1_pos++;
11809
11810 if (strlen (mac1_pos) != 12) continue;
11811
11812 uint essid_length = mac1_pos - line_buf_cpy - 1;
11813
11814 // here we need the ESSID
11815 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11816
11817 hash_buf.salt->salt_len = essid_length;
11818
11819 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11820
11821 if (found)
11822 {
11823 wpa_t *wpa = (wpa_t *) found->esalt;
11824
11825 uint pke[25] = { 0 };
11826
11827 char *pke_ptr = (char *) pke;
11828
11829 for (uint i = 0; i < 25; i++)
11830 {
11831 pke[i] = byte_swap_32 (wpa->pke[i]);
11832 }
11833
11834 u8 mac1[6] = { 0 };
11835 u8 mac2[6] = { 0 };
11836
11837 memcpy (mac1, pke_ptr + 23, 6);
11838 memcpy (mac2, pke_ptr + 29, 6);
11839
11840 // compare hex string(s) vs binary MAC address(es)
11841
11842 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11843 {
11844 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
11845 {
11846 found = NULL;
11847 break;
11848 }
11849 }
11850
11851 // early skip ;)
11852 if (!found) continue;
11853
11854 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11855 {
11856 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
11857 {
11858 found = NULL;
11859 break;
11860 }
11861 }
11862 }
11863 }
11864 }
11865 else
11866 {
11867 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
11868
11869 if (parser_status == PARSER_OK)
11870 {
11871 if (isSalted)
11872 {
11873 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11874 }
11875 else
11876 {
11877 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11878 }
11879 }
11880 }
11881
11882 if (found == NULL) continue;
11883
11884 if (!found->cracked) potfile_remove_cracks++;
11885
11886 found->cracked = 1;
11887
11888 if (found) break;
11889
11890 iter--;
11891 }
11892 }
11893
11894 fclose (fp);
11895 }
11896 }
11897
11898 if (esalt_size)
11899 {
11900 local_free (hash_buf.esalt);
11901 }
11902
11903 if (isSalted)
11904 {
11905 local_free (hash_buf.salt);
11906 }
11907
11908 local_free (hash_buf.digest);
11909 }
11910
11911 /**
11912 * Now generate all the buffers required for later
11913 */
11914
11915 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
11916
11917 salt_t *salts_buf_new = NULL;
11918 void *esalts_buf_new = NULL;
11919
11920 if (isSalted)
11921 {
11922 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11923
11924 if (esalt_size)
11925 {
11926 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
11927 }
11928 }
11929 else
11930 {
11931 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
11932 }
11933
11934 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
11935
11936 uint digests_cnt = hashes_cnt;
11937 uint digests_done = 0;
11938
11939 uint size_digests = digests_cnt * dgst_size;
11940 uint size_shown = digests_cnt * sizeof (uint);
11941
11942 uint *digests_shown = (uint *) mymalloc (size_shown);
11943 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
11944
11945 uint salts_cnt = 0;
11946 uint salts_done = 0;
11947
11948 hashinfo_t **hash_info = NULL;
11949
11950 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11951 {
11952 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
11953
11954 if (username && (remove || show))
11955 {
11956 uint user_pos;
11957
11958 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
11959 {
11960 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
11961
11962 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
11963 }
11964 }
11965 }
11966
11967 uint *salts_shown = (uint *) mymalloc (size_shown);
11968
11969 salt_t *salt_buf;
11970
11971 {
11972 // copied from inner loop
11973
11974 salt_buf = &salts_buf_new[salts_cnt];
11975
11976 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
11977
11978 if (esalt_size)
11979 {
11980 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
11981 }
11982
11983 salt_buf->digests_cnt = 0;
11984 salt_buf->digests_done = 0;
11985 salt_buf->digests_offset = 0;
11986
11987 salts_cnt++;
11988 }
11989
11990 if (hashes_buf[0].cracked == 1)
11991 {
11992 digests_shown[0] = 1;
11993
11994 digests_done++;
11995
11996 salt_buf->digests_done++;
11997 }
11998
11999 salt_buf->digests_cnt++;
12000
12001 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12002
12003 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12004 {
12005 hash_info[0] = hashes_buf[0].hash_info;
12006 }
12007
12008 // copy from inner loop
12009
12010 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12011 {
12012 if (isSalted)
12013 {
12014 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12015 {
12016 salt_buf = &salts_buf_new[salts_cnt];
12017
12018 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12019
12020 if (esalt_size)
12021 {
12022 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12023 }
12024
12025 salt_buf->digests_cnt = 0;
12026 salt_buf->digests_done = 0;
12027 salt_buf->digests_offset = hashes_pos;
12028
12029 salts_cnt++;
12030 }
12031 }
12032
12033 if (hashes_buf[hashes_pos].cracked == 1)
12034 {
12035 digests_shown[hashes_pos] = 1;
12036
12037 digests_done++;
12038
12039 salt_buf->digests_done++;
12040 }
12041
12042 salt_buf->digests_cnt++;
12043
12044 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12045
12046 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12047 {
12048 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12049 }
12050 }
12051
12052 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12053 {
12054 salt_t *salt_buf = &salts_buf_new[salt_pos];
12055
12056 if (salt_buf->digests_done == salt_buf->digests_cnt)
12057 {
12058 salts_shown[salt_pos] = 1;
12059
12060 salts_done++;
12061 }
12062
12063 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12064 }
12065
12066 local_free (digests_buf);
12067 local_free (salts_buf);
12068 local_free (esalts_buf);
12069
12070 digests_buf = digests_buf_new;
12071 salts_buf = salts_buf_new;
12072 esalts_buf = esalts_buf_new;
12073
12074 local_free (hashes_buf);
12075
12076 /**
12077 * special modification not set from parser
12078 */
12079
12080 switch (hash_mode)
12081 {
12082 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12083 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12084 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12085 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12086 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12087 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12088 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12089 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12090 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12091 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12092 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12093 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12094 }
12095
12096 if (truecrypt_keyfiles)
12097 {
12098 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12099
12100 char *keyfiles = strdup (truecrypt_keyfiles);
12101
12102 char *keyfile = strtok (keyfiles, ",");
12103
12104 do
12105 {
12106 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12107
12108 } while ((keyfile = strtok (NULL, ",")) != NULL);
12109
12110 free (keyfiles);
12111 }
12112
12113 data.digests_cnt = digests_cnt;
12114 data.digests_done = digests_done;
12115 data.digests_buf = digests_buf;
12116 data.digests_shown = digests_shown;
12117 data.digests_shown_tmp = digests_shown_tmp;
12118
12119 data.salts_cnt = salts_cnt;
12120 data.salts_done = salts_done;
12121 data.salts_buf = salts_buf;
12122 data.salts_shown = salts_shown;
12123
12124 data.esalts_buf = esalts_buf;
12125 data.hash_info = hash_info;
12126
12127 /**
12128 * Automatic Optimizers
12129 */
12130
12131 if (salts_cnt == 1)
12132 opti_type |= OPTI_TYPE_SINGLE_SALT;
12133
12134 if (digests_cnt == 1)
12135 opti_type |= OPTI_TYPE_SINGLE_HASH;
12136
12137 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12138 opti_type |= OPTI_TYPE_NOT_ITERATED;
12139
12140 if (attack_mode == ATTACK_MODE_BF)
12141 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12142
12143 data.opti_type = opti_type;
12144
12145 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12146 {
12147 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12148 {
12149 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12150 {
12151 if (opts_type & OPTS_TYPE_ST_ADD80)
12152 {
12153 opts_type &= ~OPTS_TYPE_ST_ADD80;
12154 opts_type |= OPTS_TYPE_PT_ADD80;
12155 }
12156
12157 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12158 {
12159 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12160 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12161 }
12162
12163 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12164 {
12165 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12166 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12167 }
12168 }
12169 }
12170 }
12171
12172 /**
12173 * Some algorithm, like descrypt, can benefit from JIT compilation
12174 */
12175
12176 int force_jit_compilation = -1;
12177
12178 if (hash_mode == 8900)
12179 {
12180 force_jit_compilation = 8900;
12181 }
12182 else if (hash_mode == 9300)
12183 {
12184 force_jit_compilation = 8900;
12185 }
12186 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12187 {
12188 force_jit_compilation = 1500;
12189 }
12190
12191 /**
12192 * generate bitmap tables
12193 */
12194
12195 const uint bitmap_shift1 = 5;
12196 const uint bitmap_shift2 = 13;
12197
12198 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12199
12200 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12201 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12202 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12203 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12204 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12205 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12206 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12207 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12208
12209 uint bitmap_bits;
12210 uint bitmap_nums;
12211 uint bitmap_mask;
12212 uint bitmap_size;
12213
12214 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12215 {
12216 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12217
12218 bitmap_nums = 1 << bitmap_bits;
12219
12220 bitmap_mask = bitmap_nums - 1;
12221
12222 bitmap_size = bitmap_nums * sizeof (uint);
12223
12224 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12225
12226 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;
12227 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;
12228
12229 break;
12230 }
12231
12232 bitmap_nums = 1 << bitmap_bits;
12233
12234 bitmap_mask = bitmap_nums - 1;
12235
12236 bitmap_size = bitmap_nums * sizeof (uint);
12237
12238 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);
12239 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);
12240
12241 /**
12242 * prepare quick rule
12243 */
12244
12245 data.rule_buf_l = rule_buf_l;
12246 data.rule_buf_r = rule_buf_r;
12247
12248 int rule_len_l = (int) strlen (rule_buf_l);
12249 int rule_len_r = (int) strlen (rule_buf_r);
12250
12251 data.rule_len_l = rule_len_l;
12252 data.rule_len_r = rule_len_r;
12253
12254 /**
12255 * load rules
12256 */
12257
12258 uint *all_kernel_rules_cnt = NULL;
12259
12260 kernel_rule_t **all_kernel_rules_buf = NULL;
12261
12262 if (rp_files_cnt)
12263 {
12264 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12265
12266 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12267 }
12268
12269 char rule_buf[BUFSIZ] = { 0 };
12270
12271 int rule_len = 0;
12272
12273 for (uint i = 0; i < rp_files_cnt; i++)
12274 {
12275 uint kernel_rules_avail = 0;
12276
12277 uint kernel_rules_cnt = 0;
12278
12279 kernel_rule_t *kernel_rules_buf = NULL;
12280
12281 char *rp_file = rp_files[i];
12282
12283 char in[BLOCK_SIZE] = { 0 };
12284 char out[BLOCK_SIZE] = { 0 };
12285
12286 FILE *fp = NULL;
12287
12288 uint rule_line = 0;
12289
12290 if ((fp = fopen (rp_file, "rb")) == NULL)
12291 {
12292 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12293
12294 return (-1);
12295 }
12296
12297 while (!feof (fp))
12298 {
12299 memset (rule_buf, 0, BUFSIZ);
12300
12301 rule_len = fgetl (fp, rule_buf);
12302
12303 rule_line++;
12304
12305 if (rule_len == 0) continue;
12306
12307 if (rule_buf[0] == '#') continue;
12308
12309 if (kernel_rules_avail == kernel_rules_cnt)
12310 {
12311 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12312
12313 kernel_rules_avail += INCR_RULES;
12314 }
12315
12316 memset (in, 0, BLOCK_SIZE);
12317 memset (out, 0, BLOCK_SIZE);
12318
12319 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12320
12321 if (result == -1)
12322 {
12323 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12324
12325 continue;
12326 }
12327
12328 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12329 {
12330 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12331
12332 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12333
12334 continue;
12335 }
12336
12337 /* its so slow
12338 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12339 {
12340 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12341
12342 continue;
12343 }
12344 */
12345
12346 kernel_rules_cnt++;
12347 }
12348
12349 fclose (fp);
12350
12351 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12352
12353 all_kernel_rules_buf[i] = kernel_rules_buf;
12354 }
12355
12356 /**
12357 * merge rules or automatic rule generator
12358 */
12359
12360 uint kernel_rules_cnt = 0;
12361
12362 kernel_rule_t *kernel_rules_buf = NULL;
12363
12364 if (attack_mode == ATTACK_MODE_STRAIGHT)
12365 {
12366 if (rp_files_cnt)
12367 {
12368 kernel_rules_cnt = 1;
12369
12370 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12371
12372 repeats[0] = kernel_rules_cnt;
12373
12374 for (uint i = 0; i < rp_files_cnt; i++)
12375 {
12376 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12377
12378 repeats[i + 1] = kernel_rules_cnt;
12379 }
12380
12381 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12382
12383 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12384
12385 for (uint i = 0; i < kernel_rules_cnt; i++)
12386 {
12387 uint out_pos = 0;
12388
12389 kernel_rule_t *out = &kernel_rules_buf[i];
12390
12391 for (uint j = 0; j < rp_files_cnt; j++)
12392 {
12393 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12394 uint in_pos;
12395
12396 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12397
12398 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12399 {
12400 if (out_pos == RULES_MAX - 1)
12401 {
12402 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12403
12404 break;
12405 }
12406
12407 out->cmds[out_pos] = in->cmds[in_pos];
12408 }
12409 }
12410 }
12411
12412 local_free (repeats);
12413 }
12414 else if (rp_gen)
12415 {
12416 uint kernel_rules_avail = 0;
12417
12418 while (kernel_rules_cnt < rp_gen)
12419 {
12420 if (kernel_rules_avail == kernel_rules_cnt)
12421 {
12422 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12423
12424 kernel_rules_avail += INCR_RULES;
12425 }
12426
12427 memset (rule_buf, 0, BLOCK_SIZE);
12428
12429 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12430
12431 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12432
12433 kernel_rules_cnt++;
12434 }
12435 }
12436 }
12437
12438 /**
12439 * generate NOP rules
12440 */
12441
12442 if (kernel_rules_cnt == 0)
12443 {
12444 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12445
12446 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12447
12448 kernel_rules_cnt++;
12449 }
12450
12451 data.kernel_rules_cnt = kernel_rules_cnt;
12452 data.kernel_rules_buf = kernel_rules_buf;
12453
12454 /**
12455 * OpenCL platforms: detect
12456 */
12457
12458 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
12459 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
12460
12461 cl_uint platforms_cnt = 0;
12462 cl_uint platform_devices_cnt = 0;
12463
12464 if (keyspace == 0)
12465 {
12466 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12467
12468 if (platforms_cnt == 0)
12469 {
12470 log_error ("ERROR: No OpenCL compatible platform found");
12471
12472 return (-1);
12473 }
12474 }
12475
12476 /**
12477 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12478 */
12479
12480 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12481 {
12482 cl_platform_id platform = platforms[platform_id];
12483
12484 char platform_vendor[INFOSZ] = { 0 };
12485
12486 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12487
12488 #ifdef HAVE_HWMON
12489 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12490 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12491 {
12492 // make sure that we do not directly control the fan for NVidia
12493
12494 gpu_temp_retain = 0;
12495
12496 data.gpu_temp_retain = gpu_temp_retain;
12497 }
12498 #endif // HAVE_NVML || HAVE_NVAPI
12499 #endif
12500 }
12501
12502 /**
12503 * OpenCL devices: simply push all devices from all platforms into the same device array
12504 */
12505
12506 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12507
12508 data.devices_param = devices_param;
12509
12510 uint devices_cnt = 0;
12511
12512 uint devices_active = 0;
12513
12514 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12515 {
12516 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12517
12518 cl_platform_id platform = platforms[platform_id];
12519
12520 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12521
12522 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12523 {
12524 size_t param_value_size = 0;
12525
12526 const uint device_id = devices_cnt;
12527
12528 hc_device_param_t *device_param = &data.devices_param[device_id];
12529
12530 device_param->device = platform_devices[platform_devices_id];
12531
12532 device_param->device_id = device_id;
12533
12534 device_param->platform_devices_id = platform_devices_id;
12535
12536 // device_type
12537
12538 cl_device_type device_type;
12539
12540 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12541
12542 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12543
12544 device_param->device_type = device_type;
12545
12546 // vendor_id
12547
12548 cl_uint vendor_id = 0;
12549
12550 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR_ID, sizeof (vendor_id), &vendor_id, NULL);
12551
12552 device_param->vendor_id = vendor_id;
12553
12554 // device_name
12555
12556 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
12557
12558 char *device_name = (char *) mymalloc (param_value_size);
12559
12560 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
12561
12562 device_param->device_name = device_name;
12563
12564 // tuning db
12565
12566 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
12567
12568 // device_version
12569
12570 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
12571
12572 char *device_version = (char *) mymalloc (param_value_size);
12573
12574 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
12575
12576 device_param->device_version = device_version;
12577
12578 // device_opencl_version
12579
12580 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
12581
12582 char *device_opencl_version = (char *) mymalloc (param_value_size);
12583
12584 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
12585
12586 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
12587
12588 myfree (device_opencl_version);
12589
12590 if (strstr (device_version, "pocl"))
12591 {
12592 // pocl returns the real vendor_id in CL_DEVICE_VENDOR_ID which causes many problems because of hms and missing amd_bfe () etc
12593 // we need to overwrite vendor_id to avoid this. maybe open pocl issue?
12594
12595 cl_uint vendor_id = VENDOR_ID_GENERIC;
12596
12597 device_param->vendor_id = vendor_id;
12598 }
12599
12600 // vector_width
12601
12602 cl_uint vector_width;
12603
12604 if (opencl_vector_width_chgd == 0)
12605 {
12606 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
12607 {
12608 if (opti_type & OPTI_TYPE_USES_BITS_64)
12609 {
12610 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
12611 }
12612 else
12613 {
12614 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12615 }
12616 }
12617 else
12618 {
12619 vector_width = (cl_uint) tuningdb_entry->vector_width;
12620 }
12621 }
12622 else
12623 {
12624 vector_width = opencl_vector_width;
12625 }
12626
12627 if (vector_width > 16) vector_width = 16;
12628
12629 device_param->vector_width = vector_width;
12630
12631 // max_compute_units
12632
12633 cl_uint device_processors;
12634
12635 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12636
12637 device_param->device_processors = device_processors;
12638
12639 // max_mem_alloc_size
12640
12641 cl_ulong device_maxmem_alloc;
12642
12643 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12644
12645 device_param->device_maxmem_alloc = device_maxmem_alloc;
12646
12647 // max_mem_alloc_size
12648
12649 cl_ulong device_global_mem;
12650
12651 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12652
12653 device_param->device_global_mem = device_global_mem;
12654
12655 // max_clock_frequency
12656
12657 cl_uint device_maxclock_frequency;
12658
12659 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12660
12661 device_param->device_maxclock_frequency = device_maxclock_frequency;
12662
12663 // skipped
12664
12665 const u32 skipped1 = ((devices_filter & (1 << device_id)) == 0);
12666 const u32 skipped2 = ((device_types_filter & (device_type)) == 0);
12667
12668 device_param->skipped = (skipped1 || skipped2);
12669
12670 // driver_version
12671 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
12672
12673 char *driver_version = (char *) mymalloc (param_value_size);
12674
12675 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
12676
12677 device_param->driver_version = driver_version;
12678
12679 // device_name_chksum
12680
12681 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12682
12683 #if __x86_64__
12684 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);
12685 #else
12686 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);
12687 #endif
12688
12689 uint device_name_digest[4] = { 0 };
12690
12691 md5_64 ((uint *) device_name_chksum, device_name_digest);
12692
12693 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
12694
12695 device_param->device_name_chksum = device_name_chksum;
12696
12697 // device_processor_cores
12698
12699 if (device_type & CL_DEVICE_TYPE_CPU)
12700 {
12701 cl_uint device_processor_cores = 1;
12702
12703 device_param->device_processor_cores = device_processor_cores;
12704 }
12705
12706 if (device_type & CL_DEVICE_TYPE_GPU)
12707 {
12708 if (vendor_id == VENDOR_ID_AMD)
12709 {
12710 cl_uint device_processor_cores = 0;
12711
12712 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12713
12714 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12715
12716 device_param->device_processor_cores = device_processor_cores;
12717 }
12718 else if (vendor_id == VENDOR_ID_NV)
12719 {
12720 cl_uint kernel_exec_timeout = 0;
12721
12722 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12723
12724 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12725
12726 device_param->kernel_exec_timeout = kernel_exec_timeout;
12727
12728 cl_uint device_processor_cores = 0;
12729
12730 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12731
12732 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12733
12734 device_param->device_processor_cores = device_processor_cores;
12735
12736 cl_uint sm_minor = 0;
12737 cl_uint sm_major = 0;
12738
12739 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12740 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12741
12742 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12743 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12744
12745 device_param->sm_minor = sm_minor;
12746 device_param->sm_major = sm_major;
12747 }
12748 else
12749 {
12750 cl_uint device_processor_cores = 1;
12751
12752 device_param->device_processor_cores = device_processor_cores;
12753 }
12754 }
12755
12756 // display results
12757
12758 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12759 {
12760 if (device_param->skipped == 0)
12761 {
12762 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12763 device_id + 1,
12764 device_name,
12765 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
12766 (unsigned int) (device_global_mem / 1024 / 1024),
12767 (unsigned int) (device_maxclock_frequency),
12768 (unsigned int) device_processors);
12769 }
12770 else
12771 {
12772 log_info ("Device #%u: %s, skipped",
12773 device_id + 1,
12774 device_name);
12775 }
12776 }
12777
12778 // common driver check
12779
12780 if (device_param->skipped == 0)
12781 {
12782 if (strstr (device_version, "pocl"))
12783 {
12784 if (force == 0)
12785 {
12786 log_info ("");
12787 log_info ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
12788 log_info ("You are STRONGLY encouraged not to use it");
12789 log_info ("You can use --force to override this but do not post error reports if you do so");
12790 log_info ("");
12791
12792 return (-1);
12793 }
12794 }
12795
12796 if (device_type & CL_DEVICE_TYPE_GPU)
12797 {
12798 if (vendor_id == VENDOR_ID_NV)
12799 {
12800 if (device_param->kernel_exec_timeout != 0)
12801 {
12802 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);
12803 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12804 }
12805 }
12806 else if (vendor_id == VENDOR_ID_AMD)
12807 {
12808 int catalyst_check = (force == 1) ? 0 : 1;
12809
12810 int catalyst_warn = 0;
12811
12812 int catalyst_broken = 0;
12813
12814 if (catalyst_check == 1)
12815 {
12816 catalyst_warn = 1;
12817
12818 // v14.9 and higher
12819 if (atoi (device_param->driver_version) >= 1573)
12820 {
12821 catalyst_warn = 0;
12822 }
12823
12824 catalyst_check = 0;
12825 }
12826
12827 if (catalyst_broken == 1)
12828 {
12829 log_info ("");
12830 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
12831 log_info ("It will pass over cracked hashes and does not report them as cracked");
12832 log_info ("You are STRONGLY encouraged not to use it");
12833 log_info ("You can use --force to override this but do not post error reports if you do so");
12834 log_info ("");
12835
12836 return (-1);
12837 }
12838
12839 if (catalyst_warn == 1)
12840 {
12841 log_info ("");
12842 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
12843 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
12844 log_info ("See oclHashcat's homepage for official supported catalyst drivers");
12845 #ifdef _WIN
12846 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
12847 #endif
12848 log_info ("You can use --force to override this but do not post error reports if you do so");
12849 log_info ("");
12850
12851 return (-1);
12852 }
12853 }
12854 }
12855
12856 /**
12857 * kernel accel and loops tuning db adjustment
12858 */
12859
12860 device_param->kernel_accel_min = 1;
12861 device_param->kernel_accel_max = 1024;
12862
12863 device_param->kernel_loops_min = 1;
12864 device_param->kernel_loops_max = 1024;
12865
12866 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
12867
12868 if (tuningdb_entry)
12869 {
12870 u32 _kernel_accel = tuningdb_entry->kernel_accel;
12871 u32 _kernel_loops = tuningdb_entry->kernel_loops;
12872
12873 if (_kernel_accel)
12874 {
12875 device_param->kernel_accel_min = _kernel_accel;
12876 device_param->kernel_accel_max = _kernel_accel;
12877 }
12878
12879 if (_kernel_loops)
12880 {
12881 if (workload_profile == 1)
12882 {
12883 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
12884 }
12885 else if (workload_profile == 2)
12886 {
12887 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
12888 }
12889
12890 device_param->kernel_loops_min = _kernel_loops;
12891 device_param->kernel_loops_max = _kernel_loops;
12892 }
12893 }
12894
12895 // commandline parameters overwrite tuningdb entries
12896
12897 if (kernel_accel)
12898 {
12899 device_param->kernel_accel_min = kernel_accel;
12900 device_param->kernel_accel_max = kernel_accel;
12901 }
12902
12903 if (kernel_loops)
12904 {
12905 device_param->kernel_loops_min = kernel_loops;
12906 device_param->kernel_loops_max = kernel_loops;
12907 }
12908
12909 /**
12910 * activate device
12911 */
12912
12913 devices_active++;
12914 }
12915
12916 // next please
12917
12918 devices_cnt++;
12919 }
12920 }
12921
12922 if (keyspace == 0 && devices_active == 0)
12923 {
12924 log_error ("ERROR: No devices found/left");
12925
12926 return (-1);
12927 }
12928
12929 data.devices_cnt = devices_cnt;
12930
12931 data.devices_active = devices_active;
12932
12933 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12934 {
12935 log_info ("");
12936 }
12937
12938 /**
12939 * HM devices: init
12940 */
12941
12942 #ifdef HAVE_HWMON
12943 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12944 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
12945 #endif
12946
12947 #ifdef HAVE_ADL
12948 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
12949 #endif
12950
12951 if (gpu_temp_disable == 0)
12952 {
12953 #if defined(WIN) && defined(HAVE_NVAPI)
12954 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
12955
12956 if (nvapi_init (nvapi) == 0)
12957 data.hm_nv = nvapi;
12958
12959 if (data.hm_nv)
12960 {
12961 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
12962 {
12963 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
12964
12965 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12966
12967 int tmp_out = 0;
12968
12969 for (int i = 0; i < tmp_in; i++)
12970 {
12971 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
12972 }
12973
12974 for (int i = 0; i < tmp_out; i++)
12975 {
12976 NV_GPU_COOLER_SETTINGS pCoolerSettings;
12977
12978 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
12979
12980 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;
12981 }
12982 }
12983 }
12984 #endif // WIN && HAVE_NVAPI
12985
12986 #if defined(LINUX) && defined(HAVE_NVML)
12987 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
12988
12989 if (nvml_init (nvml) == 0)
12990 data.hm_nv = nvml;
12991
12992 if (data.hm_nv)
12993 {
12994 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
12995 {
12996 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
12997
12998 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12999
13000 int tmp_out = 0;
13001
13002 for (int i = 0; i < tmp_in; i++)
13003 {
13004 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13005 }
13006
13007 for (int i = 0; i < tmp_out; i++)
13008 {
13009 unsigned int speed;
13010
13011 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;
13012 }
13013 }
13014 }
13015 #endif // LINUX && HAVE_NVML
13016
13017 data.hm_amd = NULL;
13018
13019 #ifdef HAVE_ADL
13020 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13021
13022 if (adl_init (adl) == 0)
13023 data.hm_amd = adl;
13024
13025 if (data.hm_amd)
13026 {
13027 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13028 {
13029 // total number of adapters
13030
13031 int hm_adapters_num;
13032
13033 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13034
13035 // adapter info
13036
13037 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13038
13039 if (lpAdapterInfo == NULL) return (-1);
13040
13041 // get a list (of ids of) valid/usable adapters
13042
13043 int num_adl_adapters = 0;
13044
13045 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13046
13047 if (num_adl_adapters > 0)
13048 {
13049 hc_thread_mutex_lock (mux_adl);
13050
13051 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13052
13053 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13054
13055 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13056 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13057
13058 hc_thread_mutex_unlock (mux_adl);
13059 }
13060
13061 myfree (valid_adl_device_list);
13062 myfree (lpAdapterInfo);
13063 }
13064 }
13065 #endif // HAVE_ADL
13066
13067 if (data.hm_amd == NULL && data.hm_nv == NULL)
13068 {
13069 gpu_temp_disable = 1;
13070 }
13071 }
13072
13073 /**
13074 * OpenCL devices: allocate buffer for device specific information
13075 */
13076
13077 #ifdef HAVE_HWMON
13078 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13079
13080 #ifdef HAVE_ADL
13081 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13082
13083 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13084 #endif // ADL
13085 #endif
13086
13087 /**
13088 * enable custom signal handler(s)
13089 */
13090
13091 if (benchmark == 0)
13092 {
13093 hc_signal (sigHandler_default);
13094 }
13095 else
13096 {
13097 hc_signal (sigHandler_benchmark);
13098 }
13099
13100 /**
13101 * User-defined GPU temp handling
13102 */
13103
13104 #ifdef HAVE_HWMON
13105 if (gpu_temp_disable == 1)
13106 {
13107 gpu_temp_abort = 0;
13108 gpu_temp_retain = 0;
13109 }
13110
13111 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13112 {
13113 if (gpu_temp_abort < gpu_temp_retain)
13114 {
13115 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13116
13117 return (-1);
13118 }
13119 }
13120
13121 data.gpu_temp_disable = gpu_temp_disable;
13122 data.gpu_temp_abort = gpu_temp_abort;
13123 data.gpu_temp_retain = gpu_temp_retain;
13124 #endif
13125
13126 /**
13127 * inform the user
13128 */
13129
13130 if (data.quiet == 0)
13131 {
13132 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13133
13134 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);
13135
13136 if (attack_mode == ATTACK_MODE_STRAIGHT)
13137 {
13138 log_info ("Rules: %u", kernel_rules_cnt);
13139 }
13140
13141 if (opti_type)
13142 {
13143 log_info ("Applicable Optimizers:");
13144
13145 for (uint i = 0; i < 32; i++)
13146 {
13147 const uint opti_bit = 1u << i;
13148
13149 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13150 }
13151 }
13152
13153 /**
13154 * Watchdog and Temperature balance
13155 */
13156
13157 #ifdef HAVE_HWMON
13158 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13159 {
13160 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13161 }
13162
13163 if (gpu_temp_abort == 0)
13164 {
13165 log_info ("Watchdog: Temperature abort trigger disabled");
13166 }
13167 else
13168 {
13169 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13170 }
13171
13172 if (gpu_temp_retain == 0)
13173 {
13174 log_info ("Watchdog: Temperature retain trigger disabled");
13175 }
13176 else
13177 {
13178 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13179 }
13180 #endif
13181 }
13182
13183 if (data.quiet == 0) log_info ("");
13184
13185 /**
13186 * HM devices: copy
13187 */
13188
13189 if (gpu_temp_disable == 0)
13190 {
13191 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13192 {
13193 hc_device_param_t *device_param = &data.devices_param[device_id];
13194
13195 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13196
13197 if (device_param->skipped) continue;
13198
13199 const uint platform_devices_id = device_param->platform_devices_id;
13200
13201 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13202 if (device_param->vendor_id == VENDOR_ID_NV)
13203 {
13204 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13205 }
13206 #endif
13207
13208 #ifdef HAVE_ADL
13209 if (device_param->vendor_id == VENDOR_ID_AMD)
13210 {
13211 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13212 }
13213 #endif
13214 }
13215 }
13216
13217 /*
13218 * Temporary fix:
13219 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13220 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13221 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13222 * Driver / ADL bug?
13223 */
13224
13225 #ifdef HAVE_ADL
13226 if (powertune_enable == 1)
13227 {
13228 hc_thread_mutex_lock (mux_adl);
13229
13230 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13231 {
13232 hc_device_param_t *device_param = &data.devices_param[device_id];
13233
13234 if (device_param->skipped) continue;
13235
13236 if (data.hm_device[device_id].od_version == 6)
13237 {
13238 // set powertune value only
13239
13240 int powertune_supported = 0;
13241
13242 int ADL_rc = 0;
13243
13244 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13245 {
13246 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13247
13248 return (-1);
13249 }
13250
13251 if (powertune_supported != 0)
13252 {
13253 // powertune set
13254 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13255
13256 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13257 {
13258 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13259
13260 return (-1);
13261 }
13262
13263 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13264 {
13265 log_error ("ERROR: Failed to set new ADL PowerControl values");
13266
13267 return (-1);
13268 }
13269 }
13270 }
13271 }
13272
13273 hc_thread_mutex_unlock (mux_adl);
13274 }
13275 #endif // HAVE_ADK
13276 #endif // HAVE_HWMON
13277
13278 #ifdef DEBUG
13279 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
13280 #endif
13281
13282 uint kernel_power_all = 0;
13283
13284 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13285 {
13286 /**
13287 * host buffer
13288 */
13289
13290 hc_device_param_t *device_param = &data.devices_param[device_id];
13291
13292 if (device_param->skipped) continue;
13293
13294 /**
13295 * device properties
13296 */
13297
13298 const char *device_name_chksum = device_param->device_name_chksum;
13299 const u32 device_processors = device_param->device_processors;
13300 const u32 device_processor_cores = device_param->device_processor_cores;
13301
13302 /**
13303 * create context for each device
13304 */
13305
13306 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
13307
13308 /**
13309 * create command-queue
13310 */
13311
13312 // not supported with NV
13313 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13314
13315 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
13316
13317 /**
13318 * create input buffers on device : calculate size of fixed memory buffers
13319 */
13320
13321 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13322 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13323
13324 device_param->size_root_css = size_root_css;
13325 device_param->size_markov_css = size_markov_css;
13326
13327 uint size_results = KERNEL_THREADS * sizeof (uint);
13328
13329 device_param->size_results = size_results;
13330
13331 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13332 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13333
13334 uint size_plains = digests_cnt * sizeof (plain_t);
13335 uint size_salts = salts_cnt * sizeof (salt_t);
13336 uint size_esalts = salts_cnt * esalt_size;
13337
13338 device_param->size_plains = size_plains;
13339 device_param->size_digests = size_digests;
13340 device_param->size_shown = size_shown;
13341 device_param->size_salts = size_salts;
13342
13343 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13344 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13345 uint size_tm = 32 * sizeof (bs_word_t);
13346
13347 // scryptV stuff
13348
13349 u64 size_scryptV = 1;
13350
13351 if ((hash_mode == 8900) || (hash_mode == 9300))
13352 {
13353 uint tmto_start = 0;
13354 uint tmto_stop = 10;
13355
13356 if (scrypt_tmto)
13357 {
13358 tmto_start = scrypt_tmto;
13359 }
13360 else
13361 {
13362 // in case the user did not specify the tmto manually
13363 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13364 // but set the lower end only in case the user has a device with too less memory
13365
13366 if (hash_mode == 8900)
13367 {
13368 if (device_param->vendor_id == VENDOR_ID_AMD)
13369 {
13370 tmto_start = 1;
13371 }
13372 else if (device_param->vendor_id == VENDOR_ID_NV)
13373 {
13374 tmto_start = 3;
13375 }
13376 }
13377 else if (hash_mode == 9300)
13378 {
13379 if (device_param->vendor_id == VENDOR_ID_AMD)
13380 {
13381 tmto_start = 3;
13382 }
13383 else if (device_param->vendor_id == VENDOR_ID_NV)
13384 {
13385 tmto_start = 5;
13386 }
13387 }
13388 }
13389
13390 if (quiet == 0) log_info ("");
13391
13392 uint shader_per_mp = 1;
13393
13394 if (device_param->vendor_id == VENDOR_ID_AMD)
13395 {
13396 shader_per_mp = 8;
13397 }
13398 else if (device_param->vendor_id == VENDOR_ID_NV)
13399 {
13400 shader_per_mp = 32;
13401 }
13402
13403 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13404 {
13405 // TODO: in theory the following calculation needs to be done per salt, not global
13406 // we assume all hashes have the same scrypt settings
13407
13408 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13409
13410 size_scryptV /= 1 << tmto;
13411
13412 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13413
13414 if (size_scryptV > device_param->device_maxmem_alloc)
13415 {
13416 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13417
13418 continue;
13419 }
13420
13421 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13422 {
13423 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13424 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13425 }
13426
13427 break;
13428 }
13429
13430 if (data.salts_buf[0].scrypt_phy == 0)
13431 {
13432 log_error ("ERROR: can't allocate enough device memory");
13433
13434 return -1;
13435 }
13436
13437 if (quiet == 0) log_info ("");
13438 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13439 }
13440
13441 /**
13442 * create input buffers on device : calculate size of dynamic size memory buffers
13443 */
13444
13445 uint kernel_threads = KERNEL_THREADS;
13446
13447 // some algorithms need a fixed kernel-threads count (mostly because of shared memory usage)
13448
13449 if (hash_mode == 3200) kernel_threads = 8;
13450 if (hash_mode == 9000) kernel_threads = 8;
13451
13452 /**
13453 * some algorithms need a fixed kernel-loops count
13454 */
13455
13456 if (hash_mode == 1500)
13457 {
13458 const u32 kernel_loops_fixed = 1024;
13459
13460 device_param->kernel_loops_min = kernel_loops_fixed;
13461 device_param->kernel_loops_max = kernel_loops_fixed;
13462 }
13463
13464 if (hash_mode == 3000)
13465 {
13466 const u32 kernel_loops_fixed = 1024;
13467
13468 device_param->kernel_loops_min = kernel_loops_fixed;
13469 device_param->kernel_loops_max = kernel_loops_fixed;
13470 }
13471
13472 if (hash_mode == 8900)
13473 {
13474 const u32 kernel_loops_fixed = 1;
13475
13476 device_param->kernel_loops_min = kernel_loops_fixed;
13477 device_param->kernel_loops_max = kernel_loops_fixed;
13478 }
13479
13480 if (hash_mode == 9300)
13481 {
13482 const u32 kernel_loops_fixed = 1;
13483
13484 device_param->kernel_loops_min = kernel_loops_fixed;
13485 device_param->kernel_loops_max = kernel_loops_fixed;
13486 }
13487
13488 if (hash_mode == 12500)
13489 {
13490 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
13491
13492 device_param->kernel_loops_min = kernel_loops_fixed;
13493 device_param->kernel_loops_max = kernel_loops_fixed;
13494 }
13495
13496 /**
13497 * some algorithms have a maximum kernel-loops count
13498 */
13499
13500 if (attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
13501 {
13502 if (data.salts_buf[0].salt_iter < device_param->kernel_loops_max)
13503 {
13504 device_param->kernel_loops_max = data.salts_buf[0].salt_iter;
13505 }
13506 }
13507
13508 /**
13509 * some algorithms need a special kernel-accel
13510 */
13511
13512 if (hash_mode == 8900)
13513 {
13514 device_param->kernel_accel_min = 1;
13515 device_param->kernel_accel_max = 64;
13516 }
13517
13518 if (hash_mode == 9300)
13519 {
13520 device_param->kernel_accel_min = 1;
13521 device_param->kernel_accel_max = 64;
13522 }
13523
13524 u32 kernel_accel_min = device_param->kernel_accel_min;
13525 u32 kernel_accel_max = device_param->kernel_accel_max;
13526
13527 // find out if we would request too much memory on memory blocks which are based on kernel_accel
13528
13529 uint size_pws = 4;
13530 uint size_tmps = 4;
13531 uint size_hooks = 4;
13532
13533 while (kernel_accel_max >= kernel_accel_min)
13534 {
13535 uint kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
13536
13537 // size_pws
13538
13539 size_pws = kernel_power_max * sizeof (pw_t);
13540
13541 // size_tmps
13542
13543 switch (hash_mode)
13544 {
13545 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
13546 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13547 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13548 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13549 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
13550 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
13551 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
13552 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
13553 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
13554 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
13555 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13556 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13557 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13558 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13559 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13560 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13561 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13562 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13563 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13564 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13565 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13566 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13567 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13568 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
13569 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
13570 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
13571 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
13572 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
13573 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13574 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13575 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
13576 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
13577 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13578 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
13579 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13580 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
13581 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
13582 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13583 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13584 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
13585 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
13586 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
13587 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13588 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
13589 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
13590 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
13591 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
13592 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13593 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
13594 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
13595 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
13596 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
13597 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13598 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
13599 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
13600 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
13601 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
13602 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
13603 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13604 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13605 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13606 };
13607
13608 // size_hooks
13609
13610 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13611 {
13612 // none yet
13613 }
13614
13615 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
13616 // if not, decrease amplifier and try again
13617
13618 int skip = 0;
13619
13620 if (size_pws > device_param->device_maxmem_alloc) skip = 1;
13621 if (size_tmps > device_param->device_maxmem_alloc) skip = 1;
13622 if (size_hooks > device_param->device_maxmem_alloc) skip = 1;
13623
13624 if (( bitmap_size
13625 + bitmap_size
13626 + bitmap_size
13627 + bitmap_size
13628 + bitmap_size
13629 + bitmap_size
13630 + bitmap_size
13631 + bitmap_size
13632 + size_bfs
13633 + size_combs
13634 + size_digests
13635 + size_esalts
13636 + size_hooks
13637 + size_markov_css
13638 + size_plains
13639 + size_pws
13640 + size_results
13641 + size_root_css
13642 + size_rules
13643 + size_rules_c
13644 + size_salts
13645 + size_scryptV
13646 + size_shown
13647 + size_tm
13648 + size_tmps) > device_param->device_global_mem) skip = 1;
13649
13650 if (skip == 1)
13651 {
13652 kernel_accel_max--;
13653
13654 continue;
13655 }
13656
13657 break;
13658 }
13659
13660 /*
13661 if (kernel_accel_max == 0)
13662 {
13663 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
13664
13665 return -1;
13666 }
13667 */
13668
13669 device_param->kernel_accel_min = kernel_accel_min;
13670 device_param->kernel_accel_max = kernel_accel_max;
13671
13672 /*
13673 if (kernel_accel_max < kernel_accel)
13674 {
13675 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
13676
13677 device_param->kernel_accel = kernel_accel_max;
13678 }
13679 */
13680
13681 device_param->size_pws = size_pws;
13682 device_param->size_tmps = size_tmps;
13683 device_param->size_hooks = size_hooks;
13684
13685 // do not confuse kernel_accel_max with kernel_accel here
13686
13687 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
13688
13689 device_param->kernel_threads = kernel_threads;
13690 device_param->kernel_power_user = kernel_power;
13691
13692 kernel_power_all += kernel_power;
13693
13694 /**
13695 * default building options
13696 */
13697
13698 char build_opts[1024] = { 0 };
13699
13700 // we don't have sm_* on vendors not NV but it doesn't matter
13701
13702 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);
13703
13704 /**
13705 * main kernel
13706 */
13707
13708 {
13709 /**
13710 * kernel source filename
13711 */
13712
13713 char source_file[256] = { 0 };
13714
13715 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13716
13717 struct stat sst;
13718
13719 if (stat (source_file, &sst) == -1)
13720 {
13721 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13722
13723 return -1;
13724 }
13725
13726 /**
13727 * kernel cached filename
13728 */
13729
13730 char cached_file[256] = { 0 };
13731
13732 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
13733
13734 int cached = 1;
13735
13736 struct stat cst;
13737
13738 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
13739 {
13740 cached = 0;
13741 }
13742
13743 /**
13744 * kernel compile or load
13745 */
13746
13747 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13748
13749 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13750
13751 if (force_jit_compilation == -1)
13752 {
13753 if (cached == 0)
13754 {
13755 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13756
13757 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13758
13759 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13760
13761 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
13762
13763 if (rc != 0)
13764 {
13765 device_param->skipped = true;
13766 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13767 continue;
13768 }
13769
13770 size_t binary_size;
13771
13772 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13773
13774 u8 *binary = (u8 *) mymalloc (binary_size);
13775
13776 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13777
13778 writeProgramBin (cached_file, binary, binary_size);
13779
13780 local_free (binary);
13781 }
13782 else
13783 {
13784 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13785
13786 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13787
13788 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13789
13790 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
13791 }
13792 }
13793 else
13794 {
13795 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13796
13797 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13798
13799 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13800
13801 char build_opts_update[1024] = { 0 };
13802
13803 if (force_jit_compilation == 1500)
13804 {
13805 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13806 }
13807 else if (force_jit_compilation == 8900)
13808 {
13809 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);
13810 }
13811 else
13812 {
13813 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
13814 }
13815
13816 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
13817
13818 if (rc != 0)
13819 {
13820 device_param->skipped = true;
13821
13822 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13823 }
13824 }
13825
13826 local_free (kernel_lengths);
13827 local_free (kernel_sources[0]);
13828 local_free (kernel_sources);
13829 }
13830
13831 /**
13832 * word generator kernel
13833 */
13834
13835 if (attack_mode != ATTACK_MODE_STRAIGHT)
13836 {
13837 /**
13838 * kernel mp source filename
13839 */
13840
13841 char source_file[256] = { 0 };
13842
13843 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
13844
13845 struct stat sst;
13846
13847 if (stat (source_file, &sst) == -1)
13848 {
13849 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13850
13851 return -1;
13852 }
13853
13854 /**
13855 * kernel mp cached filename
13856 */
13857
13858 char cached_file[256] = { 0 };
13859
13860 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
13861
13862 int cached = 1;
13863
13864 struct stat cst;
13865
13866 if (stat (cached_file, &cst) == -1)
13867 {
13868 cached = 0;
13869 }
13870
13871 /**
13872 * kernel compile or load
13873 */
13874
13875 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13876
13877 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13878
13879 if (cached == 0)
13880 {
13881 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13882
13883 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13884
13885 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13886
13887 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
13888
13889 if (rc != 0)
13890 {
13891 device_param->skipped = true;
13892 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13893 continue;
13894 }
13895
13896 size_t binary_size;
13897
13898 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13899
13900 u8 *binary = (u8 *) mymalloc (binary_size);
13901
13902 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13903
13904 writeProgramBin (cached_file, binary, binary_size);
13905
13906 local_free (binary);
13907 }
13908 else
13909 {
13910 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13911
13912 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13913
13914 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13915
13916 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
13917 }
13918
13919 local_free (kernel_lengths);
13920 local_free (kernel_sources[0]);
13921 local_free (kernel_sources);
13922 }
13923
13924 /**
13925 * amplifier kernel
13926 */
13927
13928 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13929 {
13930
13931 }
13932 else
13933 {
13934 /**
13935 * kernel amp source filename
13936 */
13937
13938 char source_file[256] = { 0 };
13939
13940 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
13941
13942 struct stat sst;
13943
13944 if (stat (source_file, &sst) == -1)
13945 {
13946 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13947
13948 return -1;
13949 }
13950
13951 /**
13952 * kernel amp cached filename
13953 */
13954
13955 char cached_file[256] = { 0 };
13956
13957 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
13958
13959 int cached = 1;
13960
13961 struct stat cst;
13962
13963 if (stat (cached_file, &cst) == -1)
13964 {
13965 cached = 0;
13966 }
13967
13968 /**
13969 * kernel compile or load
13970 */
13971
13972 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13973
13974 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13975
13976 if (cached == 0)
13977 {
13978 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13979
13980 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13981
13982 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13983
13984 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
13985
13986 if (rc != 0)
13987 {
13988 device_param->skipped = true;
13989 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13990 continue;
13991 }
13992
13993 size_t binary_size;
13994
13995 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13996
13997 u8 *binary = (u8 *) mymalloc (binary_size);
13998
13999 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14000
14001 writeProgramBin (cached_file, binary, binary_size);
14002
14003 local_free (binary);
14004 }
14005 else
14006 {
14007 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14008
14009 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14010
14011 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14012
14013 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
14014 }
14015
14016 local_free (kernel_lengths);
14017 local_free (kernel_sources[0]);
14018 local_free (kernel_sources);
14019 }
14020
14021 // some algorithm collide too fast, make that impossible
14022
14023 if (benchmark == 1)
14024 {
14025 ((uint *) digests_buf)[0] = -1;
14026 ((uint *) digests_buf)[1] = -1;
14027 ((uint *) digests_buf)[2] = -1;
14028 ((uint *) digests_buf)[3] = -1;
14029 }
14030
14031 /**
14032 * global buffers
14033 */
14034
14035 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14036 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14037 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
14038 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
14039 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14040 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14041 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14042 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14043 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14044 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14045 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14046 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14047 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
14048 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
14049 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
14050 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
14051 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
14052 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
14053
14054 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);
14055 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);
14056 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);
14057 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);
14058 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);
14059 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);
14060 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);
14061 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);
14062 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
14063 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
14064 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
14065
14066 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
14067 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
14068 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
14069 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
14070 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
14071 run_kernel_bzero (device_param, device_param->d_result, size_results);
14072
14073 /**
14074 * special buffers
14075 */
14076
14077 if (attack_kern == ATTACK_KERN_STRAIGHT)
14078 {
14079 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
14080 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
14081
14082 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
14083
14084 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
14085 }
14086 else if (attack_kern == ATTACK_KERN_COMBI)
14087 {
14088 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14089 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14090 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14091 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14092
14093 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
14094 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
14095 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14096 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14097 }
14098 else if (attack_kern == ATTACK_KERN_BF)
14099 {
14100 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14101 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14102 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
14103 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14104 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14105
14106 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
14107 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
14108 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
14109 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14110 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14111 }
14112
14113 if (size_esalts)
14114 {
14115 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
14116
14117 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
14118 }
14119
14120 /**
14121 * main host data
14122 */
14123
14124 uint *result = (uint *) mymalloc (size_results);
14125
14126 device_param->result = result;
14127
14128 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
14129
14130 device_param->pws_buf = pws_buf;
14131
14132 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
14133
14134 device_param->combs_buf = combs_buf;
14135
14136 void *hooks_buf = mymalloc (size_hooks);
14137
14138 device_param->hooks_buf = hooks_buf;
14139
14140 /**
14141 * kernel args
14142 */
14143
14144 device_param->kernel_params_buf32[21] = bitmap_mask;
14145 device_param->kernel_params_buf32[22] = bitmap_shift1;
14146 device_param->kernel_params_buf32[23] = bitmap_shift2;
14147 device_param->kernel_params_buf32[24] = 0; // salt_pos
14148 device_param->kernel_params_buf32[25] = 0; // loop_pos
14149 device_param->kernel_params_buf32[26] = 0; // loop_cnt
14150 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
14151 device_param->kernel_params_buf32[28] = 0; // digests_cnt
14152 device_param->kernel_params_buf32[29] = 0; // digests_offset
14153 device_param->kernel_params_buf32[30] = 0; // combs_mode
14154 device_param->kernel_params_buf32[31] = 0; // gid_max
14155
14156 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14157 ? &device_param->d_pws_buf
14158 : &device_param->d_pws_amp_buf;
14159 device_param->kernel_params[ 1] = &device_param->d_rules_c;
14160 device_param->kernel_params[ 2] = &device_param->d_combs_c;
14161 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
14162 device_param->kernel_params[ 4] = &device_param->d_tmps;
14163 device_param->kernel_params[ 5] = &device_param->d_hooks;
14164 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
14165 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
14166 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
14167 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
14168 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
14169 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
14170 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
14171 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
14172 device_param->kernel_params[14] = &device_param->d_plain_bufs;
14173 device_param->kernel_params[15] = &device_param->d_digests_buf;
14174 device_param->kernel_params[16] = &device_param->d_digests_shown;
14175 device_param->kernel_params[17] = &device_param->d_salt_bufs;
14176 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
14177 device_param->kernel_params[19] = &device_param->d_result;
14178 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
14179 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
14180 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
14181 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
14182 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
14183 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
14184 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
14185 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
14186 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
14187 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
14188 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
14189 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
14190
14191 device_param->kernel_params_mp_buf64[3] = 0;
14192 device_param->kernel_params_mp_buf32[4] = 0;
14193 device_param->kernel_params_mp_buf32[5] = 0;
14194 device_param->kernel_params_mp_buf32[6] = 0;
14195 device_param->kernel_params_mp_buf32[7] = 0;
14196 device_param->kernel_params_mp_buf32[8] = 0;
14197
14198 device_param->kernel_params_mp[0] = NULL;
14199 device_param->kernel_params_mp[1] = NULL;
14200 device_param->kernel_params_mp[2] = NULL;
14201 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
14202 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
14203 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
14204 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
14205 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
14206 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
14207
14208 device_param->kernel_params_mp_l_buf64[3] = 0;
14209 device_param->kernel_params_mp_l_buf32[4] = 0;
14210 device_param->kernel_params_mp_l_buf32[5] = 0;
14211 device_param->kernel_params_mp_l_buf32[6] = 0;
14212 device_param->kernel_params_mp_l_buf32[7] = 0;
14213 device_param->kernel_params_mp_l_buf32[8] = 0;
14214 device_param->kernel_params_mp_l_buf32[9] = 0;
14215
14216 device_param->kernel_params_mp_l[0] = NULL;
14217 device_param->kernel_params_mp_l[1] = NULL;
14218 device_param->kernel_params_mp_l[2] = NULL;
14219 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14220 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14221 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14222 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14223 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14224 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14225 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14226
14227 device_param->kernel_params_mp_r_buf64[3] = 0;
14228 device_param->kernel_params_mp_r_buf32[4] = 0;
14229 device_param->kernel_params_mp_r_buf32[5] = 0;
14230 device_param->kernel_params_mp_r_buf32[6] = 0;
14231 device_param->kernel_params_mp_r_buf32[7] = 0;
14232 device_param->kernel_params_mp_r_buf32[8] = 0;
14233
14234 device_param->kernel_params_mp_r[0] = NULL;
14235 device_param->kernel_params_mp_r[1] = NULL;
14236 device_param->kernel_params_mp_r[2] = NULL;
14237 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14238 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14239 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14240 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14241 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14242 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14243
14244 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14245 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14246
14247 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14248 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14249 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14250 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14251 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14252 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14253 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14254
14255 device_param->kernel_params_tb[0] = &device_param->d_pws_buf;
14256
14257 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14258 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14259
14260 /**
14261 * kernel name
14262 */
14263
14264 char kernel_name[64] = { 0 };
14265
14266 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14267 {
14268 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14269 {
14270 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14271
14272 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14273
14274 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14275
14276 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14277
14278 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14279
14280 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14281 }
14282 else
14283 {
14284 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14285
14286 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14287
14288 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14289
14290 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14291
14292 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14293
14294 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14295 }
14296
14297 if (data.attack_mode == ATTACK_MODE_BF)
14298 {
14299 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14300 {
14301 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tb", kern_type);
14302
14303 device_param->kernel_tb = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14304
14305 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14306
14307 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14308 }
14309 }
14310 }
14311 else
14312 {
14313 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14314
14315 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14316
14317 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14318
14319 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14320
14321 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14322
14323 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14324
14325 if (opts_type & OPTS_TYPE_HOOK12)
14326 {
14327 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14328
14329 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14330 }
14331
14332 if (opts_type & OPTS_TYPE_HOOK23)
14333 {
14334 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14335
14336 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14337 }
14338 }
14339
14340 for (uint i = 0; i <= 20; i++)
14341 {
14342 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14343 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14344 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14345
14346 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14347 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14348 }
14349
14350 for (uint i = 21; i <= 31; i++)
14351 {
14352 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14353 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14354 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14355
14356 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14357 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14358 }
14359
14360 if (attack_mode == ATTACK_MODE_BF)
14361 {
14362 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
14363 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
14364
14365 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14366 {
14367 hc_clSetKernelArg (data.ocl, device_param->kernel_tb, 0, sizeof (cl_mem), device_param->kernel_params_tb[0]);
14368
14369 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14370 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14371 }
14372 }
14373 else if (attack_mode == ATTACK_MODE_HYBRID1)
14374 {
14375 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14376 }
14377 else if (attack_mode == ATTACK_MODE_HYBRID2)
14378 {
14379 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14380 }
14381
14382 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14383 {
14384 // nothing to do
14385 }
14386 else
14387 {
14388 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
14389 }
14390
14391 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14392 {
14393 // nothing to do
14394 }
14395 else
14396 {
14397 for (uint i = 0; i < 5; i++)
14398 {
14399 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14400 }
14401
14402 for (uint i = 5; i < 7; i++)
14403 {
14404 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14405 }
14406 }
14407
14408 /**
14409 * Store initial fanspeed if gpu_temp_retain is enabled
14410 */
14411
14412 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
14413 int gpu_temp_retain_set = 0;
14414
14415 if (gpu_temp_disable == 0)
14416 {
14417 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14418 {
14419 hc_thread_mutex_lock (mux_adl);
14420
14421 if (data.hm_device[device_id].fan_supported == 1)
14422 {
14423 if (gpu_temp_retain_chgd == 0)
14424 {
14425 uint cur_temp = 0;
14426 uint default_temp = 0;
14427
14428 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);
14429
14430 if (ADL_rc == ADL_OK)
14431 {
14432 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14433
14434 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14435
14436 // special case with multi gpu setups: always use minimum retain
14437
14438 if (gpu_temp_retain_set == 0)
14439 {
14440 gpu_temp_retain = gpu_temp_retain_target;
14441 gpu_temp_retain_set = 1;
14442 }
14443 else
14444 {
14445 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14446 }
14447
14448 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14449 }
14450 }
14451
14452 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14453
14454 temp_retain_fanspeed_value[device_id] = fan_speed;
14455
14456 if (fan_speed == -1)
14457 {
14458 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14459
14460 temp_retain_fanspeed_value[device_id] = 0;
14461 }
14462 }
14463
14464 hc_thread_mutex_unlock (mux_adl);
14465 }
14466 }
14467
14468 /**
14469 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14470 */
14471
14472 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14473 {
14474 hc_thread_mutex_lock (mux_adl);
14475
14476 if (data.hm_device[device_id].od_version == 6)
14477 {
14478 int ADL_rc;
14479
14480 // check powertune capabilities first, if not available then skip device
14481
14482 int powertune_supported = 0;
14483
14484 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14485 {
14486 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14487
14488 return (-1);
14489 }
14490
14491 if (powertune_supported != 0)
14492 {
14493 // powercontrol settings
14494
14495 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14496
14497 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14498 {
14499 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14500 }
14501
14502 if (ADL_rc != ADL_OK)
14503 {
14504 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14505
14506 return (-1);
14507 }
14508
14509 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14510 {
14511 log_error ("ERROR: Failed to set new ADL PowerControl values");
14512
14513 return (-1);
14514 }
14515
14516 // clocks
14517
14518 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14519
14520 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14521
14522 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)
14523 {
14524 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14525
14526 return (-1);
14527 }
14528
14529 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14530
14531 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14532
14533 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14534 {
14535 log_error ("ERROR: Failed to get ADL device capabilities");
14536
14537 return (-1);
14538 }
14539
14540 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14541 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14542
14543 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14544 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14545
14546 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14547 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14548
14549 // warning if profile has too low max values
14550
14551 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14552 {
14553 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14554 }
14555
14556 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14557 {
14558 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14559 }
14560
14561 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14562
14563 performance_state->iNumberOfPerformanceLevels = 2;
14564
14565 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14566 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14567 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14568 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14569
14570 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)
14571 {
14572 log_info ("ERROR: Failed to set ADL performance state");
14573
14574 return (-1);
14575 }
14576
14577 local_free (performance_state);
14578 }
14579 }
14580
14581 hc_thread_mutex_unlock (mux_adl);
14582 }
14583 #endif // HAVE_HWMON && HAVE_ADL
14584 }
14585
14586 data.kernel_power_all = kernel_power_all;
14587
14588 if (data.quiet == 0) log_info ("");
14589
14590 /**
14591 * Inform user which algorithm is checked and at which workload setting
14592 */
14593
14594 if (benchmark == 1)
14595 {
14596 quiet = 0;
14597
14598 data.quiet = quiet;
14599
14600 char *hash_type = strhashtype (data.hash_mode); // not a bug
14601
14602 log_info ("Hashtype: %s", hash_type);
14603 log_info ("");
14604 }
14605
14606 /**
14607 * keep track of the progress
14608 */
14609
14610 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14611 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14612 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14613
14614 /**
14615 * open filehandles
14616 */
14617
14618 #if _WIN
14619 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14620 {
14621 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14622
14623 return (-1);
14624 }
14625
14626 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14627 {
14628 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14629
14630 return (-1);
14631 }
14632
14633 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14634 {
14635 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14636
14637 return (-1);
14638 }
14639 #endif
14640
14641 /**
14642 * dictionary pad
14643 */
14644
14645 segment_size *= (1024 * 1024);
14646
14647 data.segment_size = segment_size;
14648
14649 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14650
14651 wl_data->buf = (char *) mymalloc (segment_size);
14652 wl_data->avail = segment_size;
14653 wl_data->incr = segment_size;
14654 wl_data->cnt = 0;
14655 wl_data->pos = 0;
14656
14657 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14658
14659 data.wordlist_mode = wordlist_mode;
14660
14661 cs_t *css_buf = NULL;
14662 uint css_cnt = 0;
14663 uint dictcnt = 0;
14664 uint maskcnt = 1;
14665 char **masks = NULL;
14666 char **dictfiles = NULL;
14667
14668 uint mask_from_file = 0;
14669
14670 if (attack_mode == ATTACK_MODE_STRAIGHT)
14671 {
14672 if (wordlist_mode == WL_MODE_FILE)
14673 {
14674 int wls_left = myargc - (optind + 1);
14675
14676 for (int i = 0; i < wls_left; i++)
14677 {
14678 char *l0_filename = myargv[optind + 1 + i];
14679
14680 struct stat l0_stat;
14681
14682 if (stat (l0_filename, &l0_stat) == -1)
14683 {
14684 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14685
14686 return (-1);
14687 }
14688
14689 uint is_dir = S_ISDIR (l0_stat.st_mode);
14690
14691 if (is_dir == 0)
14692 {
14693 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14694
14695 dictcnt++;
14696
14697 dictfiles[dictcnt - 1] = l0_filename;
14698 }
14699 else
14700 {
14701 // do not allow --keyspace w/ a directory
14702
14703 if (keyspace == 1)
14704 {
14705 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14706
14707 return (-1);
14708 }
14709
14710 char **dictionary_files = NULL;
14711
14712 dictionary_files = scan_directory (l0_filename);
14713
14714 if (dictionary_files != NULL)
14715 {
14716 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14717
14718 for (int d = 0; dictionary_files[d] != NULL; d++)
14719 {
14720 char *l1_filename = dictionary_files[d];
14721
14722 struct stat l1_stat;
14723
14724 if (stat (l1_filename, &l1_stat) == -1)
14725 {
14726 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14727
14728 return (-1);
14729 }
14730
14731 if (S_ISREG (l1_stat.st_mode))
14732 {
14733 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14734
14735 dictcnt++;
14736
14737 dictfiles[dictcnt - 1] = strdup (l1_filename);
14738 }
14739 }
14740 }
14741
14742 local_free (dictionary_files);
14743 }
14744 }
14745
14746 if (dictcnt < 1)
14747 {
14748 log_error ("ERROR: No usable dictionary file found.");
14749
14750 return (-1);
14751 }
14752 }
14753 else if (wordlist_mode == WL_MODE_STDIN)
14754 {
14755 dictcnt = 1;
14756 }
14757 }
14758 else if (attack_mode == ATTACK_MODE_COMBI)
14759 {
14760 // display
14761
14762 char *dictfile1 = myargv[optind + 1 + 0];
14763 char *dictfile2 = myargv[optind + 1 + 1];
14764
14765 // find the bigger dictionary and use as base
14766
14767 FILE *fp1 = NULL;
14768 FILE *fp2 = NULL;
14769
14770 struct stat tmp_stat;
14771
14772 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14773 {
14774 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14775
14776 return (-1);
14777 }
14778
14779 if (stat (dictfile1, &tmp_stat) == -1)
14780 {
14781 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14782
14783 fclose (fp1);
14784
14785 return (-1);
14786 }
14787
14788 if (S_ISDIR (tmp_stat.st_mode))
14789 {
14790 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14791
14792 fclose (fp1);
14793
14794 return (-1);
14795 }
14796
14797 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14798 {
14799 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14800
14801 fclose (fp1);
14802
14803 return (-1);
14804 }
14805
14806 if (stat (dictfile2, &tmp_stat) == -1)
14807 {
14808 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14809
14810 fclose (fp1);
14811 fclose (fp2);
14812
14813 return (-1);
14814 }
14815
14816 if (S_ISDIR (tmp_stat.st_mode))
14817 {
14818 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
14819
14820 fclose (fp1);
14821 fclose (fp2);
14822
14823 return (-1);
14824 }
14825
14826 data.combs_cnt = 1;
14827
14828 data.quiet = 1;
14829
14830 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
14831
14832 data.quiet = quiet;
14833
14834 if (words1_cnt == 0)
14835 {
14836 log_error ("ERROR: %s: empty file", dictfile1);
14837
14838 fclose (fp1);
14839 fclose (fp2);
14840
14841 return (-1);
14842 }
14843
14844 data.combs_cnt = 1;
14845
14846 data.quiet = 1;
14847
14848 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
14849
14850 data.quiet = quiet;
14851
14852 if (words2_cnt == 0)
14853 {
14854 log_error ("ERROR: %s: empty file", dictfile2);
14855
14856 fclose (fp1);
14857 fclose (fp2);
14858
14859 return (-1);
14860 }
14861
14862 fclose (fp1);
14863 fclose (fp2);
14864
14865 data.dictfile = dictfile1;
14866 data.dictfile2 = dictfile2;
14867
14868 if (words1_cnt >= words2_cnt)
14869 {
14870 data.combs_cnt = words2_cnt;
14871 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14872
14873 dictfiles = &data.dictfile;
14874
14875 dictcnt = 1;
14876 }
14877 else
14878 {
14879 data.combs_cnt = words1_cnt;
14880 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14881
14882 dictfiles = &data.dictfile2;
14883
14884 dictcnt = 1;
14885
14886 // we also have to switch wordlist related rules!
14887
14888 char *tmpc = data.rule_buf_l;
14889
14890 data.rule_buf_l = data.rule_buf_r;
14891 data.rule_buf_r = tmpc;
14892
14893 int tmpi = data.rule_len_l;
14894
14895 data.rule_len_l = data.rule_len_r;
14896 data.rule_len_r = tmpi;
14897 }
14898 }
14899 else if (attack_mode == ATTACK_MODE_BF)
14900 {
14901 char *mask = NULL;
14902
14903 maskcnt = 0;
14904
14905 if (benchmark == 0)
14906 {
14907 mask = myargv[optind + 1];
14908
14909 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
14910
14911 if ((optind + 2) <= myargc)
14912 {
14913 struct stat file_stat;
14914
14915 if (stat (mask, &file_stat) == -1)
14916 {
14917 maskcnt = 1;
14918
14919 masks[maskcnt - 1] = mystrdup (mask);
14920 }
14921 else
14922 {
14923 int wls_left = myargc - (optind + 1);
14924
14925 uint masks_avail = INCR_MASKS;
14926
14927 for (int i = 0; i < wls_left; i++)
14928 {
14929 if (i != 0)
14930 {
14931 mask = myargv[optind + 1 + i];
14932
14933 if (stat (mask, &file_stat) == -1)
14934 {
14935 log_error ("ERROR: %s: %s", mask, strerror (errno));
14936
14937 return (-1);
14938 }
14939 }
14940
14941 uint is_file = S_ISREG (file_stat.st_mode);
14942
14943 if (is_file == 1)
14944 {
14945 FILE *mask_fp;
14946
14947 if ((mask_fp = fopen (mask, "r")) == NULL)
14948 {
14949 log_error ("ERROR: %s: %s", mask, strerror (errno));
14950
14951 return (-1);
14952 }
14953
14954 char line_buf[BUFSIZ] = { 0 };
14955
14956 while (!feof (mask_fp))
14957 {
14958 memset (line_buf, 0, BUFSIZ);
14959
14960 int line_len = fgetl (mask_fp, line_buf);
14961
14962 if (line_len == 0) continue;
14963
14964 if (line_buf[0] == '#') continue;
14965
14966 if (masks_avail == maskcnt)
14967 {
14968 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14969
14970 masks_avail += INCR_MASKS;
14971 }
14972
14973 masks[maskcnt] = mystrdup (line_buf);
14974
14975 maskcnt++;
14976 }
14977
14978 fclose (mask_fp);
14979 }
14980 else
14981 {
14982 log_error ("ERROR: %s: unsupported file-type", mask);
14983
14984 return (-1);
14985 }
14986 }
14987
14988 mask_from_file = 1;
14989 }
14990 }
14991 else
14992 {
14993 custom_charset_1 = (char *) "?l?d?u";
14994 custom_charset_2 = (char *) "?l?d";
14995 custom_charset_3 = (char *) "?l?d*!$@_";
14996
14997 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
14998 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
14999 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15000
15001 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
15002
15003 wordlist_mode = WL_MODE_MASK;
15004
15005 data.wordlist_mode = wordlist_mode;
15006
15007 increment = 1;
15008
15009 maskcnt = 1;
15010 }
15011 }
15012 else
15013 {
15014 /**
15015 * generate full masks and charsets
15016 */
15017
15018 masks = (char **) mymalloc (sizeof (char *));
15019
15020 switch (hash_mode)
15021 {
15022 case 1731: pw_min = 5;
15023 pw_max = 5;
15024 mask = mystrdup ("?b?b?b?b?b");
15025 break;
15026 case 12500: pw_min = 5;
15027 pw_max = 5;
15028 mask = mystrdup ("?b?b?b?b?b");
15029 break;
15030 default: pw_min = 7;
15031 pw_max = 7;
15032 mask = mystrdup ("?b?b?b?b?b?b?b");
15033 break;
15034 }
15035
15036 maskcnt = 1;
15037
15038 masks[maskcnt - 1] = mystrdup (mask);
15039
15040 wordlist_mode = WL_MODE_MASK;
15041
15042 data.wordlist_mode = wordlist_mode;
15043
15044 increment = 1;
15045 }
15046
15047 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
15048
15049 if (increment)
15050 {
15051 if (increment_min > pw_min) pw_min = increment_min;
15052
15053 if (increment_max < pw_max) pw_max = increment_max;
15054 }
15055 }
15056 else if (attack_mode == ATTACK_MODE_HYBRID1)
15057 {
15058 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15059
15060 // display
15061
15062 char *mask = myargv[myargc - 1];
15063
15064 maskcnt = 0;
15065
15066 masks = (char **) mymalloc (1 * sizeof (char *));
15067
15068 // mod
15069
15070 struct stat file_stat;
15071
15072 if (stat (mask, &file_stat) == -1)
15073 {
15074 maskcnt = 1;
15075
15076 masks[maskcnt - 1] = mystrdup (mask);
15077 }
15078 else
15079 {
15080 uint is_file = S_ISREG (file_stat.st_mode);
15081
15082 if (is_file == 1)
15083 {
15084 FILE *mask_fp;
15085
15086 if ((mask_fp = fopen (mask, "r")) == NULL)
15087 {
15088 log_error ("ERROR: %s: %s", mask, strerror (errno));
15089
15090 return (-1);
15091 }
15092
15093 char line_buf[BUFSIZ] = { 0 };
15094
15095 uint masks_avail = 1;
15096
15097 while (!feof (mask_fp))
15098 {
15099 memset (line_buf, 0, BUFSIZ);
15100
15101 int line_len = fgetl (mask_fp, line_buf);
15102
15103 if (line_len == 0) continue;
15104
15105 if (line_buf[0] == '#') continue;
15106
15107 if (masks_avail == maskcnt)
15108 {
15109 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15110
15111 masks_avail += INCR_MASKS;
15112 }
15113
15114 masks[maskcnt] = mystrdup (line_buf);
15115
15116 maskcnt++;
15117 }
15118
15119 fclose (mask_fp);
15120
15121 mask_from_file = 1;
15122 }
15123 else
15124 {
15125 maskcnt = 1;
15126
15127 masks[maskcnt - 1] = mystrdup (mask);
15128 }
15129 }
15130
15131 // base
15132
15133 int wls_left = myargc - (optind + 2);
15134
15135 for (int i = 0; i < wls_left; i++)
15136 {
15137 char *filename = myargv[optind + 1 + i];
15138
15139 struct stat file_stat;
15140
15141 if (stat (filename, &file_stat) == -1)
15142 {
15143 log_error ("ERROR: %s: %s", filename, strerror (errno));
15144
15145 return (-1);
15146 }
15147
15148 uint is_dir = S_ISDIR (file_stat.st_mode);
15149
15150 if (is_dir == 0)
15151 {
15152 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15153
15154 dictcnt++;
15155
15156 dictfiles[dictcnt - 1] = filename;
15157 }
15158 else
15159 {
15160 // do not allow --keyspace w/ a directory
15161
15162 if (keyspace == 1)
15163 {
15164 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15165
15166 return (-1);
15167 }
15168
15169 char **dictionary_files = NULL;
15170
15171 dictionary_files = scan_directory (filename);
15172
15173 if (dictionary_files != NULL)
15174 {
15175 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15176
15177 for (int d = 0; dictionary_files[d] != NULL; d++)
15178 {
15179 char *l1_filename = dictionary_files[d];
15180
15181 struct stat l1_stat;
15182
15183 if (stat (l1_filename, &l1_stat) == -1)
15184 {
15185 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15186
15187 return (-1);
15188 }
15189
15190 if (S_ISREG (l1_stat.st_mode))
15191 {
15192 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15193
15194 dictcnt++;
15195
15196 dictfiles[dictcnt - 1] = strdup (l1_filename);
15197 }
15198 }
15199 }
15200
15201 local_free (dictionary_files);
15202 }
15203 }
15204
15205 if (dictcnt < 1)
15206 {
15207 log_error ("ERROR: No usable dictionary file found.");
15208
15209 return (-1);
15210 }
15211
15212 if (increment)
15213 {
15214 maskcnt = 0;
15215
15216 uint mask_min = increment_min; // we can't reject smaller masks here
15217 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15218
15219 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15220 {
15221 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15222
15223 if (cur_mask == NULL) break;
15224
15225 masks[maskcnt] = cur_mask;
15226
15227 maskcnt++;
15228
15229 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15230 }
15231 }
15232 }
15233 else if (attack_mode == ATTACK_MODE_HYBRID2)
15234 {
15235 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15236
15237 // display
15238
15239 char *mask = myargv[optind + 1 + 0];
15240
15241 maskcnt = 0;
15242
15243 masks = (char **) mymalloc (1 * sizeof (char *));
15244
15245 // mod
15246
15247 struct stat file_stat;
15248
15249 if (stat (mask, &file_stat) == -1)
15250 {
15251 maskcnt = 1;
15252
15253 masks[maskcnt - 1] = mystrdup (mask);
15254 }
15255 else
15256 {
15257 uint is_file = S_ISREG (file_stat.st_mode);
15258
15259 if (is_file == 1)
15260 {
15261 FILE *mask_fp;
15262
15263 if ((mask_fp = fopen (mask, "r")) == NULL)
15264 {
15265 log_error ("ERROR: %s: %s", mask, strerror (errno));
15266
15267 return (-1);
15268 }
15269
15270 char line_buf[BUFSIZ] = { 0 };
15271
15272 uint masks_avail = 1;
15273
15274 while (!feof (mask_fp))
15275 {
15276 memset (line_buf, 0, BUFSIZ);
15277
15278 int line_len = fgetl (mask_fp, line_buf);
15279
15280 if (line_len == 0) continue;
15281
15282 if (line_buf[0] == '#') continue;
15283
15284 if (masks_avail == maskcnt)
15285 {
15286 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15287
15288 masks_avail += INCR_MASKS;
15289 }
15290
15291 masks[maskcnt] = mystrdup (line_buf);
15292
15293 maskcnt++;
15294 }
15295
15296 fclose (mask_fp);
15297
15298 mask_from_file = 1;
15299 }
15300 else
15301 {
15302 maskcnt = 1;
15303
15304 masks[maskcnt - 1] = mystrdup (mask);
15305 }
15306 }
15307
15308 // base
15309
15310 int wls_left = myargc - (optind + 2);
15311
15312 for (int i = 0; i < wls_left; i++)
15313 {
15314 char *filename = myargv[optind + 2 + i];
15315
15316 struct stat file_stat;
15317
15318 if (stat (filename, &file_stat) == -1)
15319 {
15320 log_error ("ERROR: %s: %s", filename, strerror (errno));
15321
15322 return (-1);
15323 }
15324
15325 uint is_dir = S_ISDIR (file_stat.st_mode);
15326
15327 if (is_dir == 0)
15328 {
15329 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15330
15331 dictcnt++;
15332
15333 dictfiles[dictcnt - 1] = filename;
15334 }
15335 else
15336 {
15337 // do not allow --keyspace w/ a directory
15338
15339 if (keyspace == 1)
15340 {
15341 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15342
15343 return (-1);
15344 }
15345
15346 char **dictionary_files = NULL;
15347
15348 dictionary_files = scan_directory (filename);
15349
15350 if (dictionary_files != NULL)
15351 {
15352 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15353
15354 for (int d = 0; dictionary_files[d] != NULL; d++)
15355 {
15356 char *l1_filename = dictionary_files[d];
15357
15358 struct stat l1_stat;
15359
15360 if (stat (l1_filename, &l1_stat) == -1)
15361 {
15362 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15363
15364 return (-1);
15365 }
15366
15367 if (S_ISREG (l1_stat.st_mode))
15368 {
15369 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15370
15371 dictcnt++;
15372
15373 dictfiles[dictcnt - 1] = strdup (l1_filename);
15374 }
15375 }
15376 }
15377
15378 local_free (dictionary_files);
15379 }
15380 }
15381
15382 if (dictcnt < 1)
15383 {
15384 log_error ("ERROR: No usable dictionary file found.");
15385
15386 return (-1);
15387 }
15388
15389 if (increment)
15390 {
15391 maskcnt = 0;
15392
15393 uint mask_min = increment_min; // we can't reject smaller masks here
15394 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15395
15396 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15397 {
15398 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15399
15400 if (cur_mask == NULL) break;
15401
15402 masks[maskcnt] = cur_mask;
15403
15404 maskcnt++;
15405
15406 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15407 }
15408 }
15409 }
15410
15411 data.pw_min = pw_min;
15412 data.pw_max = pw_max;
15413
15414 /**
15415 * weak hash check
15416 */
15417
15418 if (weak_hash_threshold >= salts_cnt)
15419 {
15420 hc_device_param_t *device_param = NULL;
15421
15422 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15423 {
15424 device_param = &data.devices_param[device_id];
15425
15426 if (device_param->skipped) continue;
15427
15428 break;
15429 }
15430
15431 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15432
15433 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15434 {
15435 weak_hash_check (device_param, salt_pos);
15436 }
15437 }
15438
15439 // Display hack, guarantee that there is at least one \r before real start
15440
15441 if (data.quiet == 0) log_info_nn ("");
15442
15443 /**
15444 * status and monitor threads
15445 */
15446
15447 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15448
15449 hc_thread_t i_thread = 0;
15450
15451 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15452 {
15453 hc_thread_create (i_thread, thread_keypress, &benchmark);
15454 }
15455
15456 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15457
15458 uint ni_threads_cnt = 0;
15459
15460 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15461
15462 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15463
15464 ni_threads_cnt++;
15465
15466 /**
15467 * Outfile remove
15468 */
15469
15470 if (keyspace == 0)
15471 {
15472 if (outfile_check_timer != 0)
15473 {
15474 if (data.outfile_check_directory != NULL)
15475 {
15476 if ((hash_mode != 5200) &&
15477 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15478 (hash_mode != 9000))
15479 {
15480 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15481
15482 ni_threads_cnt++;
15483 }
15484 else
15485 {
15486 outfile_check_timer = 0;
15487 }
15488 }
15489 else
15490 {
15491 outfile_check_timer = 0;
15492 }
15493 }
15494 }
15495
15496 /**
15497 * Inform the user if we got some hashes remove because of the pot file remove feature
15498 */
15499
15500 if (data.quiet == 0)
15501 {
15502 if (potfile_remove_cracks > 0)
15503 {
15504 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15505 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15506 }
15507 }
15508
15509 data.outfile_check_timer = outfile_check_timer;
15510
15511 /**
15512 * main loop
15513 */
15514
15515 char **induction_dictionaries = NULL;
15516
15517 int induction_dictionaries_cnt = 0;
15518
15519 hcstat_table_t *root_table_buf = NULL;
15520 hcstat_table_t *markov_table_buf = NULL;
15521
15522 uint initial_restore_done = 0;
15523
15524 data.maskcnt = maskcnt;
15525
15526 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15527 {
15528 if (data.devices_status == STATUS_CRACKED) break;
15529
15530 data.devices_status = STATUS_INIT;
15531
15532 if (maskpos > rd->maskpos)
15533 {
15534 rd->dictpos = 0;
15535 }
15536
15537 rd->maskpos = maskpos;
15538 data.maskpos = maskpos;
15539
15540 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15541 {
15542 char *mask = masks[maskpos];
15543
15544 if (mask_from_file == 1)
15545 {
15546 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15547
15548 char *str_ptr;
15549 uint str_pos;
15550
15551 uint mask_offset = 0;
15552
15553 uint separator_cnt;
15554
15555 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15556 {
15557 str_ptr = strstr (mask + mask_offset, ",");
15558
15559 if (str_ptr == NULL) break;
15560
15561 str_pos = str_ptr - mask;
15562
15563 // escaped separator, i.e. "\,"
15564
15565 if (str_pos > 0)
15566 {
15567 if (mask[str_pos - 1] == '\\')
15568 {
15569 separator_cnt --;
15570
15571 mask_offset = str_pos + 1;
15572
15573 continue;
15574 }
15575 }
15576
15577 // reset the offset
15578
15579 mask_offset = 0;
15580
15581 mask[str_pos] = '\0';
15582
15583 switch (separator_cnt)
15584 {
15585 case 0:
15586 mp_reset_usr (mp_usr, 0);
15587
15588 custom_charset_1 = mask;
15589 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15590 break;
15591
15592 case 1:
15593 mp_reset_usr (mp_usr, 1);
15594
15595 custom_charset_2 = mask;
15596 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15597 break;
15598
15599 case 2:
15600 mp_reset_usr (mp_usr, 2);
15601
15602 custom_charset_3 = mask;
15603 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15604 break;
15605
15606 case 3:
15607 mp_reset_usr (mp_usr, 3);
15608
15609 custom_charset_4 = mask;
15610 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15611 break;
15612 }
15613
15614 mask = mask + str_pos + 1;
15615 }
15616 }
15617
15618 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15619 {
15620 if (maskpos > 0)
15621 {
15622 local_free (css_buf);
15623 local_free (data.root_css_buf);
15624 local_free (data.markov_css_buf);
15625
15626 local_free (masks[maskpos - 1]);
15627 }
15628
15629 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15630
15631 data.mask = mask;
15632 data.css_cnt = css_cnt;
15633 data.css_buf = css_buf;
15634
15635 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15636
15637 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15638
15639 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15640 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15641
15642 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15643
15644 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15645
15646 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15647 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15648
15649 data.root_css_buf = root_css_buf;
15650 data.markov_css_buf = markov_css_buf;
15651
15652 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15653
15654 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15655
15656 local_free (root_table_buf);
15657 local_free (markov_table_buf);
15658
15659 // args
15660
15661 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15662 {
15663 hc_device_param_t *device_param = &data.devices_param[device_id];
15664
15665 if (device_param->skipped) continue;
15666
15667 device_param->kernel_params_mp[0] = &device_param->d_combs;
15668 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15669 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15670
15671 device_param->kernel_params_mp_buf64[3] = 0;
15672 device_param->kernel_params_mp_buf32[4] = css_cnt;
15673 device_param->kernel_params_mp_buf32[5] = 0;
15674 device_param->kernel_params_mp_buf32[6] = 0;
15675 device_param->kernel_params_mp_buf32[7] = 0;
15676
15677 if (attack_mode == ATTACK_MODE_HYBRID1)
15678 {
15679 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15680 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15681 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15682 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15683 }
15684 else if (attack_mode == ATTACK_MODE_HYBRID2)
15685 {
15686 device_param->kernel_params_mp_buf32[5] = 0;
15687 device_param->kernel_params_mp_buf32[6] = 0;
15688 device_param->kernel_params_mp_buf32[7] = 0;
15689 }
15690
15691 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]);
15692 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]);
15693 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]);
15694
15695 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);
15696 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);
15697 }
15698 }
15699 else if (attack_mode == ATTACK_MODE_BF)
15700 {
15701 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15702
15703 if (increment)
15704 {
15705 for (uint i = 0; i < dictcnt; i++)
15706 {
15707 local_free (dictfiles[i]);
15708 }
15709
15710 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15711 {
15712 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15713
15714 if (l1_filename == NULL) break;
15715
15716 dictcnt++;
15717
15718 dictfiles[dictcnt - 1] = l1_filename;
15719 }
15720 }
15721 else
15722 {
15723 dictcnt++;
15724
15725 dictfiles[dictcnt - 1] = mask;
15726 }
15727
15728 if (dictcnt == 0)
15729 {
15730 log_error ("ERROR: Mask is too small");
15731
15732 return (-1);
15733 }
15734 }
15735 }
15736
15737 free (induction_dictionaries);
15738
15739 // induction_dictionaries_cnt = 0; // implied
15740
15741 if (attack_mode != ATTACK_MODE_BF)
15742 {
15743 if (keyspace == 0)
15744 {
15745 induction_dictionaries = scan_directory (induction_directory);
15746
15747 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15748 }
15749 }
15750
15751 if (induction_dictionaries_cnt)
15752 {
15753 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15754 }
15755
15756 /**
15757 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15758 */
15759 if (keyspace == 1)
15760 {
15761 if ((maskcnt > 1) || (dictcnt > 1))
15762 {
15763 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15764
15765 return (-1);
15766 }
15767 }
15768
15769 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15770 {
15771 char *subid = logfile_generate_subid ();
15772
15773 data.subid = subid;
15774
15775 logfile_sub_msg ("START");
15776
15777 data.devices_status = STATUS_INIT;
15778
15779 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
15780 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
15781 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
15782
15783 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15784
15785 data.cpt_pos = 0;
15786
15787 data.cpt_start = time (NULL);
15788
15789 data.cpt_total = 0;
15790
15791 if (data.restore == 0)
15792 {
15793 rd->words_cur = skip;
15794
15795 skip = 0;
15796
15797 data.skip = 0;
15798 }
15799
15800 data.ms_paused = 0;
15801
15802 data.words_cur = rd->words_cur;
15803
15804 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15805 {
15806 hc_device_param_t *device_param = &data.devices_param[device_id];
15807
15808 if (device_param->skipped) continue;
15809
15810 device_param->speed_pos = 0;
15811
15812 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
15813 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
15814 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
15815
15816 device_param->exec_pos = 0;
15817
15818 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
15819
15820 device_param->kernel_power = device_param->kernel_power_user;
15821
15822 device_param->outerloop_pos = 0;
15823 device_param->outerloop_left = 0;
15824 device_param->innerloop_pos = 0;
15825 device_param->innerloop_left = 0;
15826
15827 // some more resets:
15828
15829 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
15830
15831 device_param->pws_cnt = 0;
15832
15833 device_param->words_off = 0;
15834 device_param->words_done = 0;
15835 }
15836
15837 data.kernel_power_div = 0;
15838
15839 // figure out some workload
15840
15841 if (attack_mode == ATTACK_MODE_STRAIGHT)
15842 {
15843 if (data.wordlist_mode == WL_MODE_FILE)
15844 {
15845 char *dictfile = NULL;
15846
15847 if (induction_dictionaries_cnt)
15848 {
15849 dictfile = induction_dictionaries[0];
15850 }
15851 else
15852 {
15853 dictfile = dictfiles[dictpos];
15854 }
15855
15856 data.dictfile = dictfile;
15857
15858 logfile_sub_string (dictfile);
15859
15860 for (uint i = 0; i < rp_files_cnt; i++)
15861 {
15862 logfile_sub_var_string ("rulefile", rp_files[i]);
15863 }
15864
15865 FILE *fd2 = fopen (dictfile, "rb");
15866
15867 if (fd2 == NULL)
15868 {
15869 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15870
15871 return (-1);
15872 }
15873
15874 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15875
15876 fclose (fd2);
15877
15878 if (data.words_cnt == 0)
15879 {
15880 if (data.devices_status == STATUS_CRACKED) break;
15881 if (data.devices_status == STATUS_ABORTED) break;
15882
15883 dictpos++;
15884
15885 continue;
15886 }
15887 }
15888 }
15889 else if (attack_mode == ATTACK_MODE_COMBI)
15890 {
15891 char *dictfile = data.dictfile;
15892 char *dictfile2 = data.dictfile2;
15893
15894 logfile_sub_string (dictfile);
15895 logfile_sub_string (dictfile2);
15896
15897 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
15898 {
15899 FILE *fd2 = fopen (dictfile, "rb");
15900
15901 if (fd2 == NULL)
15902 {
15903 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15904
15905 return (-1);
15906 }
15907
15908 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15909
15910 fclose (fd2);
15911 }
15912 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
15913 {
15914 FILE *fd2 = fopen (dictfile2, "rb");
15915
15916 if (fd2 == NULL)
15917 {
15918 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15919
15920 return (-1);
15921 }
15922
15923 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
15924
15925 fclose (fd2);
15926 }
15927
15928 if (data.words_cnt == 0)
15929 {
15930 if (data.devices_status == STATUS_CRACKED) break;
15931 if (data.devices_status == STATUS_ABORTED) break;
15932
15933 dictpos++;
15934
15935 continue;
15936 }
15937 }
15938 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15939 {
15940 char *dictfile = NULL;
15941
15942 if (induction_dictionaries_cnt)
15943 {
15944 dictfile = induction_dictionaries[0];
15945 }
15946 else
15947 {
15948 dictfile = dictfiles[dictpos];
15949 }
15950
15951 data.dictfile = dictfile;
15952
15953 char *mask = data.mask;
15954
15955 logfile_sub_string (dictfile);
15956 logfile_sub_string (mask);
15957
15958 FILE *fd2 = fopen (dictfile, "rb");
15959
15960 if (fd2 == NULL)
15961 {
15962 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15963
15964 return (-1);
15965 }
15966
15967 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15968
15969 fclose (fd2);
15970
15971 if (data.words_cnt == 0)
15972 {
15973 if (data.devices_status == STATUS_CRACKED) break;
15974 if (data.devices_status == STATUS_ABORTED) break;
15975
15976 dictpos++;
15977
15978 continue;
15979 }
15980 }
15981 else if (attack_mode == ATTACK_MODE_BF)
15982 {
15983 local_free (css_buf);
15984 local_free (data.root_css_buf);
15985 local_free (data.markov_css_buf);
15986
15987 char *mask = dictfiles[dictpos];
15988
15989 logfile_sub_string (mask);
15990
15991 // base
15992
15993 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15994
15995 if (opts_type & OPTS_TYPE_PT_UNICODE)
15996 {
15997 uint css_cnt_unicode = css_cnt * 2;
15998
15999 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
16000
16001 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
16002 {
16003 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
16004
16005 css_buf_unicode[j + 1].cs_buf[0] = 0;
16006 css_buf_unicode[j + 1].cs_len = 1;
16007 }
16008
16009 free (css_buf);
16010
16011 css_buf = css_buf_unicode;
16012 css_cnt = css_cnt_unicode;
16013 }
16014
16015 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
16016
16017 uint mask_min = pw_min;
16018 uint mask_max = pw_max;
16019
16020 if (opts_type & OPTS_TYPE_PT_UNICODE)
16021 {
16022 mask_min *= 2;
16023 mask_max *= 2;
16024 }
16025
16026 if ((css_cnt < mask_min) || (css_cnt > mask_max))
16027 {
16028 if (css_cnt < mask_min)
16029 {
16030 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
16031 }
16032
16033 if (css_cnt > mask_max)
16034 {
16035 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
16036 }
16037
16038 // skip to next mask
16039
16040 dictpos++;
16041
16042 rd->dictpos = dictpos;
16043
16044 logfile_sub_msg ("STOP");
16045
16046 continue;
16047 }
16048
16049 uint save_css_cnt = css_cnt;
16050
16051 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16052 {
16053 if (opti_type & OPTI_TYPE_APPENDED_SALT)
16054 {
16055 uint salt_len = (uint) data.salts_buf[0].salt_len;
16056 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
16057
16058 uint css_cnt_salt = css_cnt + salt_len;
16059
16060 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
16061
16062 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
16063
16064 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
16065 {
16066 css_buf_salt[j].cs_buf[0] = salt_buf[i];
16067 css_buf_salt[j].cs_len = 1;
16068 }
16069
16070 free (css_buf);
16071
16072 css_buf = css_buf_salt;
16073 css_cnt = css_cnt_salt;
16074 }
16075 }
16076
16077 data.mask = mask;
16078 data.css_cnt = css_cnt;
16079 data.css_buf = css_buf;
16080
16081 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
16082
16083 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16084
16085 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16086
16087 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16088 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16089
16090 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16091
16092 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16093
16094 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16095 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16096
16097 data.root_css_buf = root_css_buf;
16098 data.markov_css_buf = markov_css_buf;
16099
16100 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16101
16102 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16103
16104 local_free (root_table_buf);
16105 local_free (markov_table_buf);
16106
16107 // copy + args
16108
16109 uint css_cnt_l = css_cnt;
16110 uint css_cnt_r;
16111
16112 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16113 {
16114 if (save_css_cnt < 6)
16115 {
16116 css_cnt_r = 1;
16117 }
16118 else if (save_css_cnt == 6)
16119 {
16120 css_cnt_r = 2;
16121 }
16122 else
16123 {
16124 if (opts_type & OPTS_TYPE_PT_UNICODE)
16125 {
16126 if (save_css_cnt == 8 || save_css_cnt == 10)
16127 {
16128 css_cnt_r = 2;
16129 }
16130 else
16131 {
16132 css_cnt_r = 4;
16133 }
16134 }
16135 else
16136 {
16137 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
16138 {
16139 css_cnt_r = 3;
16140 }
16141 else
16142 {
16143 css_cnt_r = 4;
16144 }
16145 }
16146 }
16147 }
16148 else
16149 {
16150 css_cnt_r = 1;
16151
16152 /* unfinished code?
16153 int sum = css_buf[css_cnt_r - 1].cs_len;
16154
16155 for (uint i = 1; i < 4 && i < css_cnt; i++)
16156 {
16157 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
16158
16159 css_cnt_r++;
16160
16161 sum *= css_buf[css_cnt_r - 1].cs_len;
16162 }
16163 */
16164 }
16165
16166 css_cnt_l -= css_cnt_r;
16167
16168 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
16169
16170 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16171 {
16172 hc_device_param_t *device_param = &data.devices_param[device_id];
16173
16174 if (device_param->skipped) continue;
16175
16176 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
16177 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
16178 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
16179
16180 device_param->kernel_params_mp_l_buf64[3] = 0;
16181 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
16182 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
16183 device_param->kernel_params_mp_l_buf32[6] = 0;
16184 device_param->kernel_params_mp_l_buf32[7] = 0;
16185 device_param->kernel_params_mp_l_buf32[8] = 0;
16186
16187 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
16188 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
16189 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
16190 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
16191
16192 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
16193 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
16194 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
16195
16196 device_param->kernel_params_mp_r_buf64[3] = 0;
16197 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
16198 device_param->kernel_params_mp_r_buf32[5] = 0;
16199 device_param->kernel_params_mp_r_buf32[6] = 0;
16200 device_param->kernel_params_mp_r_buf32[7] = 0;
16201
16202 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]);
16203 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]);
16204 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]);
16205
16206 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]);
16207 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]);
16208 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]);
16209
16210 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);
16211 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);
16212 }
16213 }
16214
16215 u64 words_base = data.words_cnt;
16216
16217 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16218 {
16219 if (data.kernel_rules_cnt)
16220 {
16221 words_base /= data.kernel_rules_cnt;
16222 }
16223 }
16224 else if (data.attack_kern == ATTACK_KERN_COMBI)
16225 {
16226 if (data.combs_cnt)
16227 {
16228 words_base /= data.combs_cnt;
16229 }
16230 }
16231 else if (data.attack_kern == ATTACK_KERN_BF)
16232 {
16233 if (data.bfs_cnt)
16234 {
16235 words_base /= data.bfs_cnt;
16236 }
16237 }
16238
16239 data.words_base = words_base;
16240
16241 if (keyspace == 1)
16242 {
16243 log_info ("%llu", (unsigned long long int) words_base);
16244
16245 return (0);
16246 }
16247
16248 if (data.words_cur > data.words_base)
16249 {
16250 log_error ("ERROR: restore value greater keyspace");
16251
16252 return (-1);
16253 }
16254
16255 if (data.words_cur)
16256 {
16257 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16258 {
16259 for (uint i = 0; i < data.salts_cnt; i++)
16260 {
16261 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16262 }
16263 }
16264 else if (data.attack_kern == ATTACK_KERN_COMBI)
16265 {
16266 for (uint i = 0; i < data.salts_cnt; i++)
16267 {
16268 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16269 }
16270 }
16271 else if (data.attack_kern == ATTACK_KERN_BF)
16272 {
16273 for (uint i = 0; i < data.salts_cnt; i++)
16274 {
16275 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16276 }
16277 }
16278 }
16279
16280 /*
16281 * Inform user about possible slow speeds
16282 */
16283
16284 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16285 {
16286 if (data.words_base < kernel_power_all)
16287 {
16288 if (quiet == 0)
16289 {
16290 log_info ("");
16291 log_info ("ATTENTION!");
16292 log_info (" The wordlist or mask you are using is too small.");
16293 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
16294 log_info (" The cracking speed will drop.");
16295 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16296 log_info ("");
16297 }
16298 }
16299 }
16300
16301 /*
16302 * Update loopback file
16303 */
16304
16305 if (loopback == 1)
16306 {
16307 time_t now;
16308
16309 time (&now);
16310
16311 uint random_num = get_random_num (0, 9999);
16312
16313 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16314
16315 data.loopback_file = loopback_file;
16316 }
16317
16318 /*
16319 * Update dictionary statistic
16320 */
16321
16322 if (keyspace == 0)
16323 {
16324 dictstat_fp = fopen (dictstat, "wb");
16325
16326 if (dictstat_fp)
16327 {
16328 lock_file (dictstat_fp);
16329
16330 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16331
16332 fclose (dictstat_fp);
16333 }
16334 }
16335
16336 data.devices_status = STATUS_RUNNING;
16337
16338 if (initial_restore_done == 0)
16339 {
16340 if (data.restore_disable == 0) cycle_restore ();
16341
16342 initial_restore_done = 1;
16343 }
16344
16345 hc_timer_set (&data.timer_running);
16346
16347 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16348 {
16349 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16350 {
16351 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16352 if (quiet == 0) fflush (stdout);
16353 }
16354 }
16355 else if (wordlist_mode == WL_MODE_STDIN)
16356 {
16357 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16358 if (data.quiet == 0) log_info ("");
16359 }
16360
16361 time_t runtime_start;
16362
16363 time (&runtime_start);
16364
16365 data.runtime_start = runtime_start;
16366
16367 /**
16368 * create cracker threads
16369 */
16370
16371 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
16372
16373 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16374 {
16375 hc_device_param_t *device_param = &devices_param[device_id];
16376
16377 if (wordlist_mode == WL_MODE_STDIN)
16378 {
16379 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16380 }
16381 else
16382 {
16383 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16384 }
16385 }
16386
16387 // wait for crack threads to exit
16388
16389 hc_thread_wait (data.devices_cnt, c_threads);
16390
16391 local_free (c_threads);
16392
16393 data.restore = 0;
16394
16395 // finalize task
16396
16397 logfile_sub_var_uint ("status-after-work", data.devices_status);
16398
16399 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16400
16401 if (data.devices_status == STATUS_CRACKED) break;
16402 if (data.devices_status == STATUS_ABORTED) break;
16403
16404 if (data.devices_status == STATUS_BYPASS)
16405 {
16406 data.devices_status = STATUS_RUNNING;
16407 }
16408
16409 if (induction_dictionaries_cnt)
16410 {
16411 unlink (induction_dictionaries[0]);
16412 }
16413
16414 free (induction_dictionaries);
16415
16416 if (attack_mode != ATTACK_MODE_BF)
16417 {
16418 induction_dictionaries = scan_directory (induction_directory);
16419
16420 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16421 }
16422
16423 if (benchmark == 0)
16424 {
16425 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16426 {
16427 if (quiet == 0) clear_prompt ();
16428
16429 if (quiet == 0) log_info ("");
16430
16431 if (status == 1)
16432 {
16433 status_display ();
16434 }
16435 else
16436 {
16437 if (quiet == 0) status_display ();
16438 }
16439
16440 if (quiet == 0) log_info ("");
16441 }
16442 }
16443
16444 if (attack_mode == ATTACK_MODE_BF)
16445 {
16446 dictpos++;
16447
16448 rd->dictpos = dictpos;
16449 }
16450 else
16451 {
16452 if (induction_dictionaries_cnt)
16453 {
16454 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16455 }
16456 else
16457 {
16458 dictpos++;
16459
16460 rd->dictpos = dictpos;
16461 }
16462 }
16463
16464 time_t runtime_stop;
16465
16466 time (&runtime_stop);
16467
16468 data.runtime_stop = runtime_stop;
16469
16470 logfile_sub_uint (runtime_start);
16471 logfile_sub_uint (runtime_stop);
16472
16473 logfile_sub_msg ("STOP");
16474
16475 global_free (subid);
16476 }
16477
16478 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16479
16480 if (data.devices_status == STATUS_CRACKED) break;
16481 if (data.devices_status == STATUS_ABORTED) break;
16482 if (data.devices_status == STATUS_QUIT) break;
16483
16484 if (data.devices_status == STATUS_BYPASS)
16485 {
16486 data.devices_status = STATUS_RUNNING;
16487 }
16488 }
16489
16490 // 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
16491
16492 if (attack_mode == ATTACK_MODE_STRAIGHT)
16493 {
16494 if (data.wordlist_mode == WL_MODE_FILE)
16495 {
16496 if (data.dictfile == NULL)
16497 {
16498 if (dictfiles != NULL)
16499 {
16500 data.dictfile = dictfiles[0];
16501
16502 hc_timer_set (&data.timer_running);
16503 }
16504 }
16505 }
16506 }
16507 // NOTE: combi is okay because it is already set beforehand
16508 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16509 {
16510 if (data.dictfile == NULL)
16511 {
16512 if (dictfiles != NULL)
16513 {
16514 hc_timer_set (&data.timer_running);
16515
16516 data.dictfile = dictfiles[0];
16517 }
16518 }
16519 }
16520 else if (attack_mode == ATTACK_MODE_BF)
16521 {
16522 if (data.mask == NULL)
16523 {
16524 hc_timer_set (&data.timer_running);
16525
16526 data.mask = masks[0];
16527 }
16528 }
16529
16530 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16531 {
16532 data.devices_status = STATUS_EXHAUSTED;
16533 }
16534
16535 // if cracked / aborted remove last induction dictionary
16536
16537 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16538 {
16539 struct stat induct_stat;
16540
16541 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16542 {
16543 unlink (induction_dictionaries[file_pos]);
16544 }
16545 }
16546
16547 // wait for non-interactive threads
16548
16549 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16550 {
16551 hc_thread_wait (1, &ni_threads[thread_idx]);
16552 }
16553
16554 local_free (ni_threads);
16555
16556 // wait for interactive threads
16557
16558 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16559 {
16560 hc_thread_wait (1, &i_thread);
16561 }
16562
16563 // we dont need restore file anymore
16564 if (data.restore_disable == 0)
16565 {
16566 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16567 {
16568 unlink (eff_restore_file);
16569 unlink (new_restore_file);
16570 }
16571 else
16572 {
16573 cycle_restore ();
16574 }
16575 }
16576
16577 // finally save left hashes
16578
16579 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16580 {
16581 save_hash ();
16582 }
16583
16584 /**
16585 * Clean up
16586 */
16587
16588 if (benchmark == 1)
16589 {
16590 status_benchmark ();
16591
16592 log_info ("");
16593 }
16594 else
16595 {
16596 if (quiet == 0) clear_prompt ();
16597
16598 if (quiet == 0) log_info ("");
16599
16600 if (status == 1)
16601 {
16602 status_display ();
16603 }
16604 else
16605 {
16606 if (quiet == 0) status_display ();
16607 }
16608
16609 if (quiet == 0) log_info ("");
16610 }
16611
16612 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16613 {
16614 hc_device_param_t *device_param = &data.devices_param[device_id];
16615
16616 if (device_param->skipped) continue;
16617
16618 local_free (device_param->result);
16619
16620 local_free (device_param->combs_buf);
16621
16622 local_free (device_param->hooks_buf);
16623
16624 local_free (device_param->device_name);
16625
16626 local_free (device_param->device_name_chksum);
16627
16628 local_free (device_param->device_version);
16629
16630 local_free (device_param->driver_version);
16631
16632 if (device_param->pws_buf) myfree (device_param->pws_buf);
16633 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
16634 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
16635 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
16636 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
16637 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
16638 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
16639 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
16640 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
16641 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
16642 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
16643 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
16644 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
16645 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
16646 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
16647 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
16648 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
16649 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
16650 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
16651 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
16652 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
16653 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
16654 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
16655 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
16656 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
16657 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
16658 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
16659 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
16660 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
16661
16662 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
16663 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
16664 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
16665 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
16666 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
16667 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
16668 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
16669 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
16670 if (device_param->kernel_tb) hc_clReleaseKernel (data.ocl, device_param->kernel_tb);
16671 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
16672 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
16673
16674 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
16675 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
16676 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
16677
16678 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
16679 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
16680 }
16681
16682 // reset default fan speed
16683
16684 #ifdef HAVE_HWMON
16685 if (gpu_temp_disable == 0)
16686 {
16687 #ifdef HAVE_ADL
16688 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16689 {
16690 hc_thread_mutex_lock (mux_adl);
16691
16692 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16693 {
16694 hc_device_param_t *device_param = &data.devices_param[device_id];
16695
16696 if (device_param->skipped) continue;
16697
16698 if (data.hm_device[device_id].fan_supported == 1)
16699 {
16700 int fanspeed = temp_retain_fanspeed_value[device_id];
16701
16702 if (fanspeed == -1) continue;
16703
16704 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
16705
16706 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
16707 }
16708 }
16709
16710 hc_thread_mutex_unlock (mux_adl);
16711 }
16712 #endif // HAVE_ADL
16713 }
16714
16715 #ifdef HAVE_ADL
16716 // reset power tuning
16717
16718 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16719 {
16720 hc_thread_mutex_lock (mux_adl);
16721
16722 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16723 {
16724 hc_device_param_t *device_param = &data.devices_param[device_id];
16725
16726 if (device_param->skipped) continue;
16727
16728 if (data.hm_device[device_id].od_version == 6)
16729 {
16730 // check powertune capabilities first, if not available then skip device
16731
16732 int powertune_supported = 0;
16733
16734 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
16735 {
16736 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16737
16738 return (-1);
16739 }
16740
16741 if (powertune_supported != 0)
16742 {
16743 // powercontrol settings
16744
16745 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)
16746 {
16747 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16748
16749 return (-1);
16750 }
16751
16752 // clocks
16753
16754 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16755
16756 performance_state->iNumberOfPerformanceLevels = 2;
16757
16758 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
16759 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
16760 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
16761 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
16762
16763 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)
16764 {
16765 log_info ("ERROR: Failed to restore ADL performance state");
16766
16767 return (-1);
16768 }
16769
16770 local_free (performance_state);
16771 }
16772 }
16773 }
16774
16775 hc_thread_mutex_unlock (mux_adl);
16776 }
16777 #endif // HAVE_ADL
16778
16779 if (gpu_temp_disable == 0)
16780 {
16781 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
16782 if (data.hm_nv)
16783 {
16784 #if defined(LINUX) && defined(HAVE_NVML)
16785
16786 hm_NVML_nvmlShutdown (data.hm_nv);
16787
16788 nvml_close (data.hm_nv);
16789
16790 #elif defined(WIN) && (HAVE_NVAPI)
16791
16792 hm_NvAPI_Unload (data.hm_nv);
16793
16794 nvapi_close (data.hm_nv);
16795
16796 #endif
16797
16798 data.hm_nv = NULL;
16799 }
16800 #endif
16801
16802 #ifdef HAVE_ADL
16803 if (data.hm_amd)
16804 {
16805 hm_ADL_Main_Control_Destroy (data.hm_amd);
16806
16807 adl_close (data.hm_amd);
16808 data.hm_amd = NULL;
16809 }
16810 #endif
16811 }
16812 #endif // HAVE_HWMON
16813
16814 // free memory
16815
16816 local_free (masks);
16817
16818 local_free (dictstat_base);
16819
16820 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
16821 {
16822 pot_t *pot_ptr = &pot[pot_pos];
16823
16824 hash_t *hash = &pot_ptr->hash;
16825
16826 local_free (hash->digest);
16827
16828 if (isSalted)
16829 {
16830 local_free (hash->salt);
16831 }
16832 }
16833
16834 local_free (pot);
16835
16836 local_free (all_kernel_rules_cnt);
16837 local_free (all_kernel_rules_buf);
16838
16839 local_free (wl_data->buf);
16840 local_free (wl_data);
16841
16842 local_free (bitmap_s1_a);
16843 local_free (bitmap_s1_b);
16844 local_free (bitmap_s1_c);
16845 local_free (bitmap_s1_d);
16846 local_free (bitmap_s2_a);
16847 local_free (bitmap_s2_b);
16848 local_free (bitmap_s2_c);
16849 local_free (bitmap_s2_d);
16850
16851 #ifdef HAVE_HWMON
16852 local_free (temp_retain_fanspeed_value);
16853 #ifdef HAVE_ADL
16854 local_free (od_clock_mem_status);
16855 local_free (od_power_control_status);
16856 #endif // ADL
16857 #endif
16858
16859 global_free (devices_param);
16860
16861 global_free (kernel_rules_buf);
16862
16863 global_free (root_css_buf);
16864 global_free (markov_css_buf);
16865
16866 global_free (digests_buf);
16867 global_free (digests_shown);
16868 global_free (digests_shown_tmp);
16869
16870 global_free (salts_buf);
16871 global_free (salts_shown);
16872
16873 global_free (esalts_buf);
16874
16875 global_free (words_progress_done);
16876 global_free (words_progress_rejected);
16877 global_free (words_progress_restored);
16878
16879 if (pot_fp) fclose (pot_fp);
16880
16881 if (data.devices_status == STATUS_QUIT) break;
16882 }
16883
16884 // destroy others mutex
16885
16886 hc_thread_mutex_delete (mux_dispatcher);
16887 hc_thread_mutex_delete (mux_counter);
16888 hc_thread_mutex_delete (mux_display);
16889 hc_thread_mutex_delete (mux_adl);
16890
16891 // free memory
16892
16893 local_free (eff_restore_file);
16894 local_free (new_restore_file);
16895
16896 local_free (rd);
16897
16898 // tuning db
16899
16900 tuning_db_destroy (tuning_db);
16901
16902 // loopback
16903
16904 local_free (loopback_file);
16905
16906 if (loopback == 1) unlink (loopback_file);
16907
16908 // induction directory
16909
16910 if (induction_dir == NULL)
16911 {
16912 if (attack_mode != ATTACK_MODE_BF)
16913 {
16914 if (rmdir (induction_directory) == -1)
16915 {
16916 if (errno == ENOENT)
16917 {
16918 // good, we can ignore
16919 }
16920 else if (errno == ENOTEMPTY)
16921 {
16922 // good, we can ignore
16923 }
16924 else
16925 {
16926 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
16927
16928 return (-1);
16929 }
16930 }
16931
16932 local_free (induction_directory);
16933 }
16934 }
16935
16936 // outfile-check directory
16937
16938 if (outfile_check_dir == NULL)
16939 {
16940 if (rmdir (outfile_check_directory) == -1)
16941 {
16942 if (errno == ENOENT)
16943 {
16944 // good, we can ignore
16945 }
16946 else if (errno == ENOTEMPTY)
16947 {
16948 // good, we can ignore
16949 }
16950 else
16951 {
16952 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
16953
16954 return (-1);
16955 }
16956 }
16957
16958 local_free (outfile_check_directory);
16959 }
16960
16961 time_t proc_stop;
16962
16963 time (&proc_stop);
16964
16965 logfile_top_uint (proc_start);
16966 logfile_top_uint (proc_stop);
16967
16968 logfile_top_msg ("STOP");
16969
16970 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
16971 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
16972
16973 if (data.ocl) ocl_close (data.ocl);
16974
16975 if (data.devices_status == STATUS_ABORTED) return 2;
16976 if (data.devices_status == STATUS_QUIT) return 2;
16977 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
16978 if (data.devices_status == STATUS_EXHAUSTED) return 1;
16979 if (data.devices_status == STATUS_CRACKED) return 0;
16980
16981 return -1;
16982 }
Hashcat additions to support pwdhash