projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
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 memset (device_param->pws_buf, 0, device_param->size_pws);
4499 }
4500 }
4501
4502 device_param->kernel_accel = 0;
4503 device_param->kernel_loops = 0;
4504
4505 return NULL;
4506 }
4507
4508 static void *thread_calc (void *p)
4509 {
4510 hc_device_param_t *device_param = (hc_device_param_t *) p;
4511
4512 if (device_param->skipped) return NULL;
4513
4514 autotune (device_param);
4515
4516 const uint attack_mode = data.attack_mode;
4517 const uint attack_kern = data.attack_kern;
4518
4519 if (attack_mode == ATTACK_MODE_BF)
4520 {
4521 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4522 {
4523 const uint work = get_work (device_param, -1, true);
4524
4525 if (work == 0) break;
4526
4527 const u64 words_off = device_param->words_off;
4528 const u64 words_fin = words_off + work;
4529
4530 const uint pws_cnt = work;
4531
4532 device_param->pws_cnt = pws_cnt;
4533
4534 if (pws_cnt)
4535 {
4536 run_copy (device_param, pws_cnt);
4537
4538 run_cracker (device_param, pws_cnt);
4539
4540 device_param->pws_cnt = 0;
4541 }
4542
4543 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4544
4545 if (data.devices_status == STATUS_CRACKED) break;
4546 if (data.devices_status == STATUS_ABORTED) break;
4547 if (data.devices_status == STATUS_QUIT) break;
4548 if (data.devices_status == STATUS_BYPASS) break;
4549
4550 if (data.benchmark == 1) break;
4551
4552 device_param->words_done = words_fin;
4553 }
4554 }
4555 else
4556 {
4557 const uint segment_size = data.segment_size;
4558
4559 char *dictfile = data.dictfile;
4560
4561 if (attack_mode == ATTACK_MODE_COMBI)
4562 {
4563 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4564 {
4565 dictfile = data.dictfile2;
4566 }
4567 }
4568
4569 FILE *fd = fopen (dictfile, "rb");
4570
4571 if (fd == NULL)
4572 {
4573 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4574
4575 return NULL;
4576 }
4577
4578 if (attack_mode == ATTACK_MODE_COMBI)
4579 {
4580 const uint combs_mode = data.combs_mode;
4581
4582 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4583 {
4584 const char *dictfilec = data.dictfile2;
4585
4586 FILE *combs_fp = fopen (dictfilec, "rb");
4587
4588 if (combs_fp == NULL)
4589 {
4590 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4591
4592 fclose (fd);
4593
4594 return NULL;
4595 }
4596
4597 device_param->combs_fp = combs_fp;
4598 }
4599 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4600 {
4601 const char *dictfilec = data.dictfile;
4602
4603 FILE *combs_fp = fopen (dictfilec, "rb");
4604
4605 if (combs_fp == NULL)
4606 {
4607 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4608
4609 fclose (fd);
4610
4611 return NULL;
4612 }
4613
4614 device_param->combs_fp = combs_fp;
4615 }
4616 }
4617
4618 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4619
4620 wl_data->buf = (char *) mymalloc (segment_size);
4621 wl_data->avail = segment_size;
4622 wl_data->incr = segment_size;
4623 wl_data->cnt = 0;
4624 wl_data->pos = 0;
4625
4626 u64 words_cur = 0;
4627
4628 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4629 {
4630 u64 words_off = 0;
4631 u64 words_fin = 0;
4632
4633 bool allow_div = true;
4634
4635 u64 max = -1;
4636
4637 while (max)
4638 {
4639 const uint work = get_work (device_param, max, allow_div);
4640
4641 allow_div = false;
4642
4643 if (work == 0) break;
4644
4645 words_off = device_param->words_off;
4646 words_fin = words_off + work;
4647
4648 char *line_buf;
4649 uint line_len;
4650
4651 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4652
4653 max = 0;
4654
4655 for ( ; words_cur < words_fin; words_cur++)
4656 {
4657 get_next_word (wl_data, fd, &line_buf, &line_len);
4658
4659 line_len = convert_from_hex (line_buf, line_len);
4660
4661 // post-process rule engine
4662
4663 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4664 {
4665 char rule_buf_out[BLOCK_SIZE] = { 0 };
4666
4667 int rule_len_out = -1;
4668
4669 if (line_len < BLOCK_SIZE)
4670 {
4671 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4672 }
4673
4674 if (rule_len_out < 0) continue;
4675
4676 line_buf = rule_buf_out;
4677 line_len = rule_len_out;
4678 }
4679
4680 if (attack_kern == ATTACK_KERN_STRAIGHT)
4681 {
4682 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4683 {
4684 max++;
4685
4686 hc_thread_mutex_lock (mux_counter);
4687
4688 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4689 {
4690 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4691 }
4692
4693 hc_thread_mutex_unlock (mux_counter);
4694
4695 continue;
4696 }
4697 }
4698 else if (attack_kern == ATTACK_KERN_COMBI)
4699 {
4700 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4701 // since we still need to combine the plains
4702
4703 if (line_len > data.pw_max)
4704 {
4705 max++;
4706
4707 hc_thread_mutex_lock (mux_counter);
4708
4709 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4710 {
4711 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4712 }
4713
4714 hc_thread_mutex_unlock (mux_counter);
4715
4716 continue;
4717 }
4718 }
4719
4720 pw_add (device_param, (u8 *) line_buf, line_len);
4721
4722 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4723
4724 if (data.devices_status == STATUS_CRACKED) break;
4725 if (data.devices_status == STATUS_ABORTED) break;
4726 if (data.devices_status == STATUS_QUIT) break;
4727 if (data.devices_status == STATUS_BYPASS) break;
4728 }
4729
4730 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4731
4732 if (data.devices_status == STATUS_CRACKED) break;
4733 if (data.devices_status == STATUS_ABORTED) break;
4734 if (data.devices_status == STATUS_QUIT) break;
4735 if (data.devices_status == STATUS_BYPASS) break;
4736 }
4737
4738 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4739
4740 if (data.devices_status == STATUS_CRACKED) break;
4741 if (data.devices_status == STATUS_ABORTED) break;
4742 if (data.devices_status == STATUS_QUIT) break;
4743 if (data.devices_status == STATUS_BYPASS) break;
4744
4745 //
4746 // flush
4747 //
4748
4749 const uint pws_cnt = device_param->pws_cnt;
4750
4751 if (pws_cnt)
4752 {
4753 run_copy (device_param, pws_cnt);
4754
4755 run_cracker (device_param, pws_cnt);
4756
4757 device_param->pws_cnt = 0;
4758
4759 memset (device_param->pws_buf, 0, device_param->size_pws);
4760 }
4761
4762 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4763
4764 if (data.devices_status == STATUS_CRACKED) break;
4765 if (data.devices_status == STATUS_ABORTED) break;
4766 if (data.devices_status == STATUS_QUIT) break;
4767 if (data.devices_status == STATUS_BYPASS) break;
4768
4769 if (words_fin == 0) break;
4770
4771 device_param->words_done = words_fin;
4772 }
4773
4774 if (attack_mode == ATTACK_MODE_COMBI)
4775 {
4776 fclose (device_param->combs_fp);
4777 }
4778
4779 free (wl_data->buf);
4780 free (wl_data);
4781
4782 fclose (fd);
4783 }
4784
4785 device_param->kernel_accel = 0;
4786 device_param->kernel_loops = 0;
4787
4788 return NULL;
4789 }
4790
4791 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4792 {
4793 if (!device_param)
4794 {
4795 log_error ("ERROR: %s : Invalid argument", __func__);
4796
4797 exit (-1);
4798 }
4799
4800 salt_t *salt_buf = &data.salts_buf[salt_pos];
4801
4802 device_param->kernel_params_buf32[24] = salt_pos;
4803 device_param->kernel_params_buf32[27] = 1;
4804 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4805 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4806 device_param->kernel_params_buf32[30] = 0;
4807 device_param->kernel_params_buf32[31] = 1;
4808
4809 char *dictfile_old = data.dictfile;
4810
4811 const char *weak_hash_check = "weak-hash-check";
4812
4813 data.dictfile = (char *) weak_hash_check;
4814
4815 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4816
4817 data.kernel_rules_buf[0].cmds[0] = 0;
4818
4819 /**
4820 * run the kernel
4821 */
4822
4823 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4824 {
4825 run_kernel (KERN_RUN_1, device_param, 1, false);
4826 }
4827 else
4828 {
4829 run_kernel (KERN_RUN_1, device_param, 1, false);
4830
4831 uint loop_step = 16;
4832
4833 const uint iter = salt_buf->salt_iter;
4834
4835 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4836 {
4837 uint loop_left = iter - loop_pos;
4838
4839 loop_left = MIN (loop_left, loop_step);
4840
4841 device_param->kernel_params_buf32[25] = loop_pos;
4842 device_param->kernel_params_buf32[26] = loop_left;
4843
4844 run_kernel (KERN_RUN_2, device_param, 1, false);
4845 }
4846
4847 run_kernel (KERN_RUN_3, device_param, 1, false);
4848 }
4849
4850 /**
4851 * result
4852 */
4853
4854 check_cracked (device_param, salt_pos);
4855
4856 /**
4857 * cleanup
4858 */
4859
4860 device_param->kernel_params_buf32[24] = 0;
4861 device_param->kernel_params_buf32[25] = 0;
4862 device_param->kernel_params_buf32[26] = 0;
4863 device_param->kernel_params_buf32[27] = 0;
4864 device_param->kernel_params_buf32[28] = 0;
4865 device_param->kernel_params_buf32[29] = 0;
4866 device_param->kernel_params_buf32[30] = 0;
4867 device_param->kernel_params_buf32[31] = 0;
4868
4869 data.dictfile = dictfile_old;
4870
4871 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4872 }
4873
4874 // hlfmt hashcat
4875
4876 static void hlfmt_hash_hashcat (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4877 {
4878 if (data.username == 0)
4879 {
4880 *hashbuf_pos = line_buf;
4881 *hashbuf_len = line_len;
4882 }
4883 else
4884 {
4885 char *pos = line_buf;
4886 int len = line_len;
4887
4888 for (int i = 0; i < line_len; i++, pos++, len--)
4889 {
4890 if (line_buf[i] == data.separator)
4891 {
4892 pos++;
4893
4894 len--;
4895
4896 break;
4897 }
4898 }
4899
4900 *hashbuf_pos = pos;
4901 *hashbuf_len = len;
4902 }
4903 }
4904
4905 static void hlfmt_user_hashcat (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4906 {
4907 char *pos = NULL;
4908 int len = 0;
4909
4910 int sep_cnt = 0;
4911
4912 for (int i = 0; i < line_len; i++)
4913 {
4914 if (line_buf[i] == data.separator)
4915 {
4916 sep_cnt++;
4917
4918 continue;
4919 }
4920
4921 if (sep_cnt == 0)
4922 {
4923 if (pos == NULL) pos = line_buf + i;
4924
4925 len++;
4926 }
4927 }
4928
4929 *userbuf_pos = pos;
4930 *userbuf_len = len;
4931 }
4932
4933 // hlfmt pwdump
4934
4935 static int hlfmt_detect_pwdump (char line_buf[BUFSIZ], int line_len)
4936 {
4937 int sep_cnt = 0;
4938
4939 int sep2_len = 0;
4940 int sep3_len = 0;
4941
4942 for (int i = 0; i < line_len; i++)
4943 {
4944 if (line_buf[i] == ':')
4945 {
4946 sep_cnt++;
4947
4948 continue;
4949 }
4950
4951 if (sep_cnt == 2) sep2_len++;
4952 if (sep_cnt == 3) sep3_len++;
4953 }
4954
4955 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4956
4957 return 0;
4958 }
4959
4960 static void hlfmt_hash_pwdump (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4961 {
4962 char *pos = NULL;
4963 int len = 0;
4964
4965 int sep_cnt = 0;
4966
4967 for (int i = 0; i < line_len; i++)
4968 {
4969 if (line_buf[i] == ':')
4970 {
4971 sep_cnt++;
4972
4973 continue;
4974 }
4975
4976 if (data.hash_mode == 1000)
4977 {
4978 if (sep_cnt == 3)
4979 {
4980 if (pos == NULL) pos = line_buf + i;
4981
4982 len++;
4983 }
4984 }
4985 else if (data.hash_mode == 3000)
4986 {
4987 if (sep_cnt == 2)
4988 {
4989 if (pos == NULL) pos = line_buf + i;
4990
4991 len++;
4992 }
4993 }
4994 }
4995
4996 *hashbuf_pos = pos;
4997 *hashbuf_len = len;
4998 }
4999
5000 static void hlfmt_user_pwdump (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5001 {
5002 char *pos = NULL;
5003 int len = 0;
5004
5005 int sep_cnt = 0;
5006
5007 for (int i = 0; i < line_len; i++)
5008 {
5009 if (line_buf[i] == ':')
5010 {
5011 sep_cnt++;
5012
5013 continue;
5014 }
5015
5016 if (sep_cnt == 0)
5017 {
5018 if (pos == NULL) pos = line_buf + i;
5019
5020 len++;
5021 }
5022 }
5023
5024 *userbuf_pos = pos;
5025 *userbuf_len = len;
5026 }
5027
5028 // hlfmt passwd
5029
5030 static int hlfmt_detect_passwd (char line_buf[BUFSIZ], int line_len)
5031 {
5032 int sep_cnt = 0;
5033
5034 char sep5_first = 0;
5035 char sep6_first = 0;
5036
5037 for (int i = 0; i < line_len; i++)
5038 {
5039 if (line_buf[i] == ':')
5040 {
5041 sep_cnt++;
5042
5043 continue;
5044 }
5045
5046 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5047 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5048 }
5049
5050 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5051
5052 return 0;
5053 }
5054
5055 static void hlfmt_hash_passwd (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5056 {
5057 char *pos = NULL;
5058 int len = 0;
5059
5060 int sep_cnt = 0;
5061
5062 for (int i = 0; i < line_len; i++)
5063 {
5064 if (line_buf[i] == ':')
5065 {
5066 sep_cnt++;
5067
5068 continue;
5069 }
5070
5071 if (sep_cnt == 1)
5072 {
5073 if (pos == NULL) pos = line_buf + i;
5074
5075 len++;
5076 }
5077 }
5078
5079 *hashbuf_pos = pos;
5080 *hashbuf_len = len;
5081 }
5082
5083 static void hlfmt_user_passwd (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5084 {
5085 char *pos = NULL;
5086 int len = 0;
5087
5088 int sep_cnt = 0;
5089
5090 for (int i = 0; i < line_len; i++)
5091 {
5092 if (line_buf[i] == ':')
5093 {
5094 sep_cnt++;
5095
5096 continue;
5097 }
5098
5099 if (sep_cnt == 0)
5100 {
5101 if (pos == NULL) pos = line_buf + i;
5102
5103 len++;
5104 }
5105 }
5106
5107 *userbuf_pos = pos;
5108 *userbuf_len = len;
5109 }
5110
5111 // hlfmt shadow
5112
5113 static int hlfmt_detect_shadow (char line_buf[BUFSIZ], int line_len)
5114 {
5115 int sep_cnt = 0;
5116
5117 for (int i = 0; i < line_len; i++)
5118 {
5119 if (line_buf[i] == ':') sep_cnt++;
5120 }
5121
5122 if (sep_cnt == 8) return 1;
5123
5124 return 0;
5125 }
5126
5127 static void hlfmt_hash_shadow (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5128 {
5129 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5130 }
5131
5132 static void hlfmt_user_shadow (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5133 {
5134 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5135 }
5136
5137 // hlfmt main
5138
5139 static void hlfmt_hash (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5140 {
5141 switch (hashfile_format)
5142 {
5143 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5144 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5145 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5146 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5147 }
5148 }
5149
5150 static void hlfmt_user (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5151 {
5152 switch (hashfile_format)
5153 {
5154 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5155 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5156 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5157 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5158 }
5159 }
5160
5161 static uint hlfmt_detect (FILE *fp, uint max_check)
5162 {
5163 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5164
5165 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5166 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5167
5168 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5169
5170 uint num_check = 0;
5171
5172 while (!feof (fp))
5173 {
5174 char line_buf[BUFSIZ] = { 0 };
5175
5176 int line_len = fgetl (fp, line_buf);
5177
5178 if (line_len == 0) continue;
5179
5180 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5181 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5182 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5183
5184 if (num_check == max_check) break;
5185
5186 num_check++;
5187 }
5188
5189 uint hashlist_format = HLFMT_HASHCAT;
5190
5191 for (int i = 1; i < HLFMTS_CNT; i++)
5192 {
5193 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5194
5195 hashlist_format = i;
5196 }
5197
5198 free (formats_cnt);
5199
5200 return hashlist_format;
5201 }
5202
5203 /**
5204 * some further helper function
5205 */
5206
5207 // wrapper around mymalloc for ADL
5208
5209 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5210 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5211 {
5212 return mymalloc (iSize);
5213 }
5214 #endif
5215
5216 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)
5217 {
5218 u64 collisions = 0;
5219
5220 const uint dgst_pos0 = data.dgst_pos0;
5221 const uint dgst_pos1 = data.dgst_pos1;
5222 const uint dgst_pos2 = data.dgst_pos2;
5223 const uint dgst_pos3 = data.dgst_pos3;
5224
5225 memset (bitmap_a, 0, bitmap_size);
5226 memset (bitmap_b, 0, bitmap_size);
5227 memset (bitmap_c, 0, bitmap_size);
5228 memset (bitmap_d, 0, bitmap_size);
5229
5230 for (uint i = 0; i < digests_cnt; i++)
5231 {
5232 uint *digest_ptr = (uint *) digests_buf_ptr;
5233
5234 digests_buf_ptr += dgst_size;
5235
5236 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5237 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5238 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5239 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5240
5241 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5242 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5243 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5244 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5245
5246 if (bitmap_a[idx0] & val0) collisions++;
5247 if (bitmap_b[idx1] & val1) collisions++;
5248 if (bitmap_c[idx2] & val2) collisions++;
5249 if (bitmap_d[idx3] & val3) collisions++;
5250
5251 bitmap_a[idx0] |= val0;
5252 bitmap_b[idx1] |= val1;
5253 bitmap_c[idx2] |= val2;
5254 bitmap_d[idx3] |= val3;
5255
5256 if (collisions >= collisions_max) return 0x7fffffff;
5257 }
5258
5259 return collisions;
5260 }
5261
5262 /**
5263 * main
5264 */
5265
5266 int main (int argc, char **argv)
5267 {
5268 /**
5269 * To help users a bit
5270 */
5271
5272 char *compute = getenv ("COMPUTE");
5273
5274 if (compute)
5275 {
5276 static char display[100];
5277
5278 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5279
5280 putenv (display);
5281 }
5282 else
5283 {
5284 if (getenv ("DISPLAY") == NULL)
5285 putenv ((char *) "DISPLAY=:0");
5286 }
5287
5288 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5289 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5290
5291 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5292 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5293
5294 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5295 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5296
5297 /**
5298 * Real init
5299 */
5300
5301 memset (&data, 0, sizeof (hc_global_data_t));
5302
5303 time_t proc_start;
5304
5305 time (&proc_start);
5306
5307 data.proc_start = proc_start;
5308
5309 int myargc = argc;
5310 char **myargv = argv;
5311
5312 hc_thread_mutex_init (mux_dispatcher);
5313 hc_thread_mutex_init (mux_counter);
5314 hc_thread_mutex_init (mux_display);
5315 hc_thread_mutex_init (mux_adl);
5316
5317 /**
5318 * commandline parameters
5319 */
5320
5321 uint usage = USAGE;
5322 uint version = VERSION;
5323 uint quiet = QUIET;
5324 uint benchmark = BENCHMARK;
5325 uint benchmark_repeats = BENCHMARK_REPEATS;
5326 uint show = SHOW;
5327 uint left = LEFT;
5328 uint username = USERNAME;
5329 uint remove = REMOVE;
5330 uint remove_timer = REMOVE_TIMER;
5331 u64 skip = SKIP;
5332 u64 limit = LIMIT;
5333 uint keyspace = KEYSPACE;
5334 uint potfile_disable = POTFILE_DISABLE;
5335 uint debug_mode = DEBUG_MODE;
5336 char *debug_file = NULL;
5337 char *induction_dir = NULL;
5338 char *outfile_check_dir = NULL;
5339 uint force = FORCE;
5340 uint runtime = RUNTIME;
5341 uint hash_mode = HASH_MODE;
5342 uint attack_mode = ATTACK_MODE;
5343 uint markov_disable = MARKOV_DISABLE;
5344 uint markov_classic = MARKOV_CLASSIC;
5345 uint markov_threshold = MARKOV_THRESHOLD;
5346 char *markov_hcstat = NULL;
5347 char *outfile = NULL;
5348 uint outfile_format = OUTFILE_FORMAT;
5349 uint outfile_autohex = OUTFILE_AUTOHEX;
5350 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5351 uint restore = RESTORE;
5352 uint restore_timer = RESTORE_TIMER;
5353 uint restore_disable = RESTORE_DISABLE;
5354 uint status = STATUS;
5355 uint status_timer = STATUS_TIMER;
5356 uint status_automat = STATUS_AUTOMAT;
5357 uint loopback = LOOPBACK;
5358 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5359 char *session = NULL;
5360 uint hex_charset = HEX_CHARSET;
5361 uint hex_salt = HEX_SALT;
5362 uint hex_wordlist = HEX_WORDLIST;
5363 uint rp_gen = RP_GEN;
5364 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5365 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5366 uint rp_gen_seed = RP_GEN_SEED;
5367 char *rule_buf_l = (char *) RULE_BUF_L;
5368 char *rule_buf_r = (char *) RULE_BUF_R;
5369 uint increment = INCREMENT;
5370 uint increment_min = INCREMENT_MIN;
5371 uint increment_max = INCREMENT_MAX;
5372 char *cpu_affinity = NULL;
5373 OCL_PTR *ocl = NULL;
5374 char *opencl_devices = NULL;
5375 char *opencl_platforms = NULL;
5376 char *opencl_device_types = NULL;
5377 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5378 char *truecrypt_keyfiles = NULL;
5379 uint workload_profile = WORKLOAD_PROFILE;
5380 uint kernel_accel = KERNEL_ACCEL;
5381 uint kernel_loops = KERNEL_LOOPS;
5382 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5383 #ifdef HAVE_HWMON
5384 uint gpu_temp_abort = GPU_TEMP_ABORT;
5385 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5386 #ifdef HAVE_ADL
5387 uint powertune_enable = POWERTUNE_ENABLE;
5388 #endif
5389 #endif
5390 uint logfile_disable = LOGFILE_DISABLE;
5391 uint segment_size = SEGMENT_SIZE;
5392 uint scrypt_tmto = SCRYPT_TMTO;
5393 char separator = SEPARATOR;
5394 uint bitmap_min = BITMAP_MIN;
5395 uint bitmap_max = BITMAP_MAX;
5396 char *custom_charset_1 = NULL;
5397 char *custom_charset_2 = NULL;
5398 char *custom_charset_3 = NULL;
5399 char *custom_charset_4 = NULL;
5400
5401 #define IDX_HELP 'h'
5402 #define IDX_VERSION 'V'
5403 #define IDX_VERSION_LOWER 'v'
5404 #define IDX_QUIET 0xff02
5405 #define IDX_SHOW 0xff03
5406 #define IDX_LEFT 0xff04
5407 #define IDX_REMOVE 0xff05
5408 #define IDX_REMOVE_TIMER 0xff37
5409 #define IDX_SKIP 's'
5410 #define IDX_LIMIT 'l'
5411 #define IDX_KEYSPACE 0xff35
5412 #define IDX_POTFILE_DISABLE 0xff06
5413 #define IDX_DEBUG_MODE 0xff43
5414 #define IDX_DEBUG_FILE 0xff44
5415 #define IDX_INDUCTION_DIR 0xff46
5416 #define IDX_OUTFILE_CHECK_DIR 0xff47
5417 #define IDX_USERNAME 0xff07
5418 #define IDX_FORCE 0xff08
5419 #define IDX_RUNTIME 0xff09
5420 #define IDX_BENCHMARK 'b'
5421 #define IDX_BENCHMARK_REPEATS 0xff78
5422 #define IDX_HASH_MODE 'm'
5423 #define IDX_ATTACK_MODE 'a'
5424 #define IDX_RP_FILE 'r'
5425 #define IDX_RP_GEN 'g'
5426 #define IDX_RP_GEN_FUNC_MIN 0xff10
5427 #define IDX_RP_GEN_FUNC_MAX 0xff11
5428 #define IDX_RP_GEN_SEED 0xff34
5429 #define IDX_RULE_BUF_L 'j'
5430 #define IDX_RULE_BUF_R 'k'
5431 #define IDX_INCREMENT 'i'
5432 #define IDX_INCREMENT_MIN 0xff12
5433 #define IDX_INCREMENT_MAX 0xff13
5434 #define IDX_OUTFILE 'o'
5435 #define IDX_OUTFILE_FORMAT 0xff14
5436 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5437 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5438 #define IDX_RESTORE 0xff15
5439 #define IDX_RESTORE_DISABLE 0xff27
5440 #define IDX_STATUS 0xff17
5441 #define IDX_STATUS_TIMER 0xff18
5442 #define IDX_STATUS_AUTOMAT 0xff50
5443 #define IDX_LOOPBACK 0xff38
5444 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5445 #define IDX_SESSION 0xff19
5446 #define IDX_HEX_CHARSET 0xff20
5447 #define IDX_HEX_SALT 0xff21
5448 #define IDX_HEX_WORDLIST 0xff40
5449 #define IDX_MARKOV_DISABLE 0xff22
5450 #define IDX_MARKOV_CLASSIC 0xff23
5451 #define IDX_MARKOV_THRESHOLD 't'
5452 #define IDX_MARKOV_HCSTAT 0xff24
5453 #define IDX_CPU_AFFINITY 0xff25
5454 #define IDX_OPENCL_DEVICES 'd'
5455 #define IDX_OPENCL_PLATFORMS 0xff72
5456 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5457 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5458 #define IDX_WORKLOAD_PROFILE 'w'
5459 #define IDX_KERNEL_ACCEL 'n'
5460 #define IDX_KERNEL_LOOPS 'u'
5461 #define IDX_GPU_TEMP_DISABLE 0xff29
5462 #define IDX_GPU_TEMP_ABORT 0xff30
5463 #define IDX_GPU_TEMP_RETAIN 0xff31
5464 #define IDX_POWERTUNE_ENABLE 0xff41
5465 #define IDX_LOGFILE_DISABLE 0xff51
5466 #define IDX_TRUECRYPT_KEYFILES 0xff52
5467 #define IDX_SCRYPT_TMTO 0xff61
5468 #define IDX_SEGMENT_SIZE 'c'
5469 #define IDX_SEPARATOR 'p'
5470 #define IDX_BITMAP_MIN 0xff70
5471 #define IDX_BITMAP_MAX 0xff71
5472 #define IDX_CUSTOM_CHARSET_1 '1'
5473 #define IDX_CUSTOM_CHARSET_2 '2'
5474 #define IDX_CUSTOM_CHARSET_3 '3'
5475 #define IDX_CUSTOM_CHARSET_4 '4'
5476
5477 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5478
5479 struct option long_options[] =
5480 {
5481 {"help", no_argument, 0, IDX_HELP},
5482 {"version", no_argument, 0, IDX_VERSION},
5483 {"quiet", no_argument, 0, IDX_QUIET},
5484 {"show", no_argument, 0, IDX_SHOW},
5485 {"left", no_argument, 0, IDX_LEFT},
5486 {"username", no_argument, 0, IDX_USERNAME},
5487 {"remove", no_argument, 0, IDX_REMOVE},
5488 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5489 {"skip", required_argument, 0, IDX_SKIP},
5490 {"limit", required_argument, 0, IDX_LIMIT},
5491 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5492 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5493 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5494 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5495 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5496 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5497 {"force", no_argument, 0, IDX_FORCE},
5498 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5499 {"benchmark-repeats", required_argument, 0, IDX_BENCHMARK_REPEATS},
5500 {"restore", no_argument, 0, IDX_RESTORE},
5501 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5502 {"status", no_argument, 0, IDX_STATUS},
5503 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5504 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5505 {"loopback", no_argument, 0, IDX_LOOPBACK},
5506 {"weak-hash-threshold",
5507 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5508 {"session", required_argument, 0, IDX_SESSION},
5509 {"runtime", required_argument, 0, IDX_RUNTIME},
5510 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5511 {"generate-rules-func-min",
5512 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5513 {"generate-rules-func-max",
5514 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5515 {"generate-rules-seed",
5516 required_argument, 0, IDX_RP_GEN_SEED},
5517 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5518 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5519 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5520 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5521 {"rules-file", required_argument, 0, IDX_RP_FILE},
5522 {"outfile", required_argument, 0, IDX_OUTFILE},
5523 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5524 {"outfile-autohex-disable",
5525 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5526 {"outfile-check-timer",
5527 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5528 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5529 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5530 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5531 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5532 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5533 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5534 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5535 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5536 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5537 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5538 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5539 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5540 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5541 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5542 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5543 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5544 #ifdef HAVE_HWMON
5545 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5546 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5547 #ifdef HAVE_ADL
5548 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5549 #endif
5550 #endif // HAVE_HWMON
5551 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5552 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5553 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5554 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5555 // deprecated
5556 {"seperator", required_argument, 0, IDX_SEPARATOR},
5557 {"separator", required_argument, 0, IDX_SEPARATOR},
5558 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5559 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5560 {"increment", no_argument, 0, IDX_INCREMENT},
5561 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5562 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5563 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5564 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5565 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5566 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5567
5568 {0, 0, 0, 0}
5569 };
5570
5571 uint rp_files_cnt = 0;
5572
5573 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5574
5575 int option_index = 0;
5576 int c = -1;
5577
5578 optind = 1;
5579 optopt = 0;
5580
5581 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5582 {
5583 switch (c)
5584 {
5585 case IDX_HELP: usage = 1; break;
5586 case IDX_VERSION:
5587 case IDX_VERSION_LOWER: version = 1; break;
5588 case IDX_RESTORE: restore = 1; break;
5589 case IDX_SESSION: session = optarg; break;
5590 case IDX_SHOW: show = 1; break;
5591 case IDX_LEFT: left = 1; break;
5592 case '?': return (-1);
5593 }
5594 }
5595
5596 if (optopt != 0)
5597 {
5598 log_error ("ERROR: Invalid argument specified");
5599
5600 return (-1);
5601 }
5602
5603 /**
5604 * exit functions
5605 */
5606
5607 if (version)
5608 {
5609 log_info ("%s (%s)", VERSION_TAG, VERSION_SUM);
5610
5611 return (0);
5612 }
5613
5614 if (usage)
5615 {
5616 usage_big_print (PROGNAME);
5617
5618 return (0);
5619 }
5620
5621 /**
5622 * session needs to be set, always!
5623 */
5624
5625 if (session == NULL) session = (char *) PROGNAME;
5626
5627 /**
5628 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5629 */
5630
5631 char *exec_path = get_exec_path ();
5632
5633 #ifdef LINUX
5634
5635 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5636 char *resolved_exec_path = realpath (exec_path, NULL);
5637
5638 char *install_dir = get_install_dir (resolved_exec_path);
5639 char *profile_dir = NULL;
5640 char *session_dir = NULL;
5641 char *shared_dir = NULL;
5642
5643 if (strcmp (install_dir, resolved_install_folder) == 0)
5644 {
5645 struct passwd *pw = getpwuid (getuid ());
5646
5647 const char *homedir = pw->pw_dir;
5648
5649 profile_dir = get_profile_dir (homedir);
5650 session_dir = get_session_dir (profile_dir);
5651 shared_dir = strdup (SHARED_FOLDER);
5652
5653 mkdir (profile_dir, 0700);
5654 mkdir (session_dir, 0700);
5655 }
5656 else
5657 {
5658 profile_dir = install_dir;
5659 session_dir = install_dir;
5660 shared_dir = install_dir;
5661 }
5662
5663 myfree (resolved_install_folder);
5664 myfree (resolved_exec_path);
5665
5666 #else
5667
5668 char *install_dir = get_install_dir (exec_path);
5669 char *profile_dir = install_dir;
5670 char *session_dir = install_dir;
5671 char *shared_dir = install_dir;
5672
5673 #endif
5674
5675 data.install_dir = install_dir;
5676 data.profile_dir = profile_dir;
5677 data.session_dir = session_dir;
5678 data.shared_dir = shared_dir;
5679
5680 myfree (exec_path);
5681
5682 /**
5683 * kernel cache, we need to make sure folder exist
5684 */
5685
5686 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5687
5688 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5689
5690 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5691
5692 mkdir (kernels_folder, 0700);
5693
5694 myfree (kernels_folder);
5695
5696 /**
5697 * session
5698 */
5699
5700 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5701
5702 data.session = session;
5703
5704 char *eff_restore_file = (char *) mymalloc (session_size);
5705 char *new_restore_file = (char *) mymalloc (session_size);
5706
5707 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5708 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5709
5710 data.eff_restore_file = eff_restore_file;
5711 data.new_restore_file = new_restore_file;
5712
5713 if (((show == 1) || (left == 1)) && (restore == 1))
5714 {
5715 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5716 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5717
5718 return (-1);
5719 }
5720
5721 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5722 if ((show == 1) || (left == 1))
5723 {
5724 restore_disable = 1;
5725
5726 restore = 0;
5727 }
5728
5729 data.restore_disable = restore_disable;
5730
5731 restore_data_t *rd = init_restore (argc, argv);
5732
5733 data.rd = rd;
5734
5735 /**
5736 * restore file
5737 */
5738
5739 if (restore == 1)
5740 {
5741 read_restore (eff_restore_file, rd);
5742
5743 if (rd->version_bin < RESTORE_MIN)
5744 {
5745 log_error ("ERROR: Incompatible restore-file version");
5746
5747 return (-1);
5748 }
5749
5750 myargc = rd->argc;
5751 myargv = rd->argv;
5752
5753 #ifdef _POSIX
5754 rd->pid = getpid ();
5755 #elif _WIN
5756 rd->pid = GetCurrentProcessId ();
5757 #endif
5758 }
5759
5760 uint hash_mode_chgd = 0;
5761 uint runtime_chgd = 0;
5762 uint kernel_loops_chgd = 0;
5763 uint kernel_accel_chgd = 0;
5764 uint attack_mode_chgd = 0;
5765 uint outfile_format_chgd = 0;
5766 uint rp_gen_seed_chgd = 0;
5767 uint remove_timer_chgd = 0;
5768 uint increment_min_chgd = 0;
5769 uint increment_max_chgd = 0;
5770 uint workload_profile_chgd = 0;
5771 uint opencl_vector_width_chgd = 0;
5772
5773 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5774 uint gpu_temp_retain_chgd = 0;
5775 uint gpu_temp_abort_chgd = 0;
5776 #endif
5777
5778 optind = 1;
5779 optopt = 0;
5780 option_index = 0;
5781
5782 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5783 {
5784 switch (c)
5785 {
5786 //case IDX_HELP: usage = 1; break;
5787 //case IDX_VERSION: version = 1; break;
5788 //case IDX_RESTORE: restore = 1; break;
5789 case IDX_QUIET: quiet = 1; break;
5790 //case IDX_SHOW: show = 1; break;
5791 case IDX_SHOW: break;
5792 //case IDX_LEFT: left = 1; break;
5793 case IDX_LEFT: break;
5794 case IDX_USERNAME: username = 1; break;
5795 case IDX_REMOVE: remove = 1; break;
5796 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5797 remove_timer_chgd = 1; break;
5798 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5799 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5800 case IDX_DEBUG_FILE: debug_file = optarg; break;
5801 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5802 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5803 case IDX_FORCE: force = 1; break;
5804 case IDX_SKIP: skip = atoll (optarg); break;
5805 case IDX_LIMIT: limit = atoll (optarg); break;
5806 case IDX_KEYSPACE: keyspace = 1; break;
5807 case IDX_BENCHMARK: benchmark = 1; break;
5808 case IDX_BENCHMARK_REPEATS: benchmark_repeats = atoi (optarg); break;
5809 case IDX_RESTORE: break;
5810 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5811 case IDX_STATUS: status = 1; break;
5812 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5813 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5814 case IDX_LOOPBACK: loopback = 1; break;
5815 case IDX_WEAK_HASH_THRESHOLD:
5816 weak_hash_threshold = atoi (optarg); break;
5817 //case IDX_SESSION: session = optarg; break;
5818 case IDX_SESSION: break;
5819 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5820 hash_mode_chgd = 1; break;
5821 case IDX_RUNTIME: runtime = atoi (optarg);
5822 runtime_chgd = 1; break;
5823 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5824 attack_mode_chgd = 1; break;
5825 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5826 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5827 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5828 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5829 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5830 rp_gen_seed_chgd = 1; break;
5831 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5832 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5833 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5834 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5835 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5836 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5837 case IDX_OUTFILE: outfile = optarg; break;
5838 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5839 outfile_format_chgd = 1; break;
5840 case IDX_OUTFILE_AUTOHEX_DISABLE:
5841 outfile_autohex = 0; break;
5842 case IDX_OUTFILE_CHECK_TIMER:
5843 outfile_check_timer = atoi (optarg); break;
5844 case IDX_HEX_CHARSET: hex_charset = 1; break;
5845 case IDX_HEX_SALT: hex_salt = 1; break;
5846 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5847 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5848 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5849 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5850 case IDX_OPENCL_DEVICE_TYPES:
5851 opencl_device_types = optarg; break;
5852 case IDX_OPENCL_VECTOR_WIDTH:
5853 opencl_vector_width = atoi (optarg);
5854 opencl_vector_width_chgd = 1; break;
5855 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
5856 workload_profile_chgd = 1; break;
5857 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5858 kernel_accel_chgd = 1; break;
5859 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5860 kernel_loops_chgd = 1; break;
5861 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5862 #ifdef HAVE_HWMON
5863 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5864 #ifdef HAVE_ADL
5865 gpu_temp_abort_chgd = 1;
5866 #endif
5867 break;
5868 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5869 #ifdef HAVE_ADL
5870 gpu_temp_retain_chgd = 1;
5871 #endif
5872 break;
5873 #ifdef HAVE_ADL
5874 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5875 #endif
5876 #endif // HAVE_HWMON
5877 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5878 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5879 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5880 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5881 case IDX_SEPARATOR: separator = optarg[0]; break;
5882 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5883 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5884 case IDX_INCREMENT: increment = 1; break;
5885 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5886 increment_min_chgd = 1; break;
5887 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5888 increment_max_chgd = 1; break;
5889 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5890 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5891 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5892 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5893
5894 default:
5895 log_error ("ERROR: Invalid argument specified");
5896 return (-1);
5897 }
5898 }
5899
5900 if (optopt != 0)
5901 {
5902 log_error ("ERROR: Invalid argument specified");
5903
5904 return (-1);
5905 }
5906
5907 /**
5908 * Inform user things getting started,
5909 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5910 * - we do not need to check algorithm_pos
5911 */
5912
5913 if (quiet == 0)
5914 {
5915 if (benchmark == 1)
5916 {
5917 log_info ("%s %s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5918
5919 log_info ("");
5920 }
5921 else if (restore == 1)
5922 {
5923 log_info ("%s %s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5924
5925 log_info ("");
5926 }
5927 else
5928 {
5929 log_info ("%s %s (%s) starting...", PROGNAME, VERSION_TAG, VERSION_SUM);
5930
5931 log_info ("");
5932 }
5933 }
5934
5935 /**
5936 * sanity check
5937 */
5938
5939 if (attack_mode > 7)
5940 {
5941 log_error ("ERROR: Invalid attack-mode specified");
5942
5943 return (-1);
5944 }
5945
5946 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5947 {
5948 log_error ("ERROR: Invalid runtime specified");
5949
5950 return (-1);
5951 }
5952
5953 if (hash_mode_chgd && hash_mode > 13100) // just added to remove compiler warnings for hash_mode_chgd
5954 {
5955 log_error ("ERROR: Invalid hash-type specified");
5956
5957 return (-1);
5958 }
5959
5960 // renamed hash modes
5961
5962 if (hash_mode_chgd)
5963 {
5964 int n = -1;
5965
5966 switch (hash_mode)
5967 {
5968 case 123: n = 124;
5969 break;
5970 }
5971
5972 if (n >= 0)
5973 {
5974 log_error ("Old -m specified, use -m %d instead", n);
5975
5976 return (-1);
5977 }
5978 }
5979
5980 if (username == 1)
5981 {
5982 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
5983 {
5984 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5985
5986 return (-1);
5987 }
5988 }
5989
5990 if (outfile_format > 16)
5991 {
5992 log_error ("ERROR: Invalid outfile-format specified");
5993
5994 return (-1);
5995 }
5996
5997 if (left == 1)
5998 {
5999 if (outfile_format_chgd == 1)
6000 {
6001 if (outfile_format > 1)
6002 {
6003 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6004
6005 return (-1);
6006 }
6007 }
6008 else
6009 {
6010 outfile_format = OUTFILE_FMT_HASH;
6011 }
6012 }
6013
6014 if (show == 1)
6015 {
6016 if (outfile_format_chgd == 1)
6017 {
6018 if ((outfile_format > 7) && (outfile_format < 16))
6019 {
6020 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6021
6022 return (-1);
6023 }
6024 }
6025 }
6026
6027 if (increment_min < INCREMENT_MIN)
6028 {
6029 log_error ("ERROR: Invalid increment-min specified");
6030
6031 return (-1);
6032 }
6033
6034 if (increment_max > INCREMENT_MAX)
6035 {
6036 log_error ("ERROR: Invalid increment-max specified");
6037
6038 return (-1);
6039 }
6040
6041 if (increment_min > increment_max)
6042 {
6043 log_error ("ERROR: Invalid increment-min specified");
6044
6045 return (-1);
6046 }
6047
6048 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6049 {
6050 log_error ("ERROR: increment is not allowed in attack-mode 0");
6051
6052 return (-1);
6053 }
6054
6055 if ((increment == 0) && (increment_min_chgd == 1))
6056 {
6057 log_error ("ERROR: increment-min is only supported together with increment switch");
6058
6059 return (-1);
6060 }
6061
6062 if ((increment == 0) && (increment_max_chgd == 1))
6063 {
6064 log_error ("ERROR: increment-max is only supported together with increment switch");
6065
6066 return (-1);
6067 }
6068
6069 if (rp_files_cnt && rp_gen)
6070 {
6071 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6072
6073 return (-1);
6074 }
6075
6076 if (rp_files_cnt || rp_gen)
6077 {
6078 if (attack_mode != ATTACK_MODE_STRAIGHT)
6079 {
6080 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6081
6082 return (-1);
6083 }
6084 }
6085
6086 if (rp_gen_func_min > rp_gen_func_max)
6087 {
6088 log_error ("ERROR: Invalid rp-gen-func-min specified");
6089
6090 return (-1);
6091 }
6092
6093 if (kernel_accel_chgd == 1)
6094 {
6095 if (kernel_accel < 1)
6096 {
6097 log_error ("ERROR: Invalid kernel-accel specified");
6098
6099 return (-1);
6100 }
6101
6102 if (kernel_accel > 1024)
6103 {
6104 log_error ("ERROR: Invalid kernel-accel specified");
6105
6106 return (-1);
6107 }
6108 }
6109
6110 if (kernel_loops_chgd == 1)
6111 {
6112 if (kernel_loops < 1)
6113 {
6114 log_error ("ERROR: Invalid kernel-loops specified");
6115
6116 return (-1);
6117 }
6118
6119 if (kernel_loops > 1024)
6120 {
6121 log_error ("ERROR: Invalid kernel-loops specified");
6122
6123 return (-1);
6124 }
6125 }
6126
6127 if ((workload_profile < 1) || (workload_profile > 3))
6128 {
6129 log_error ("ERROR: workload-profile %i not available", workload_profile);
6130
6131 return (-1);
6132 }
6133
6134 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6135 {
6136 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6137
6138 return (-1);
6139 }
6140
6141 if (show == 1 || left == 1)
6142 {
6143 attack_mode = ATTACK_MODE_NONE;
6144
6145 if (remove == 1)
6146 {
6147 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6148
6149 return (-1);
6150 }
6151
6152 if (potfile_disable == 1)
6153 {
6154 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6155
6156 return (-1);
6157 }
6158 }
6159
6160 uint attack_kern = ATTACK_KERN_NONE;
6161
6162 switch (attack_mode)
6163 {
6164 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6165 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6166 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6167 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6168 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6169 }
6170
6171 if (benchmark == 0)
6172 {
6173 if (keyspace == 1)
6174 {
6175 int num_additional_params = 1;
6176
6177 if (attack_kern == ATTACK_KERN_COMBI)
6178 {
6179 num_additional_params = 2;
6180 }
6181
6182 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6183
6184 if (keyspace_wordlist_specified == 0) optind--;
6185 }
6186
6187 if (attack_kern == ATTACK_KERN_NONE)
6188 {
6189 if ((optind + 1) != myargc)
6190 {
6191 usage_mini_print (myargv[0]);
6192
6193 return (-1);
6194 }
6195 }
6196 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6197 {
6198 if ((optind + 1) > myargc)
6199 {
6200 usage_mini_print (myargv[0]);
6201
6202 return (-1);
6203 }
6204 }
6205 else if (attack_kern == ATTACK_KERN_COMBI)
6206 {
6207 if ((optind + 3) != myargc)
6208 {
6209 usage_mini_print (myargv[0]);
6210
6211 return (-1);
6212 }
6213 }
6214 else if (attack_kern == ATTACK_KERN_BF)
6215 {
6216 if ((optind + 1) > myargc)
6217 {
6218 usage_mini_print (myargv[0]);
6219
6220 return (-1);
6221 }
6222 }
6223 else
6224 {
6225 usage_mini_print (myargv[0]);
6226
6227 return (-1);
6228 }
6229 }
6230 else
6231 {
6232 if (myargv[optind] != 0)
6233 {
6234 log_error ("ERROR: Invalid argument for benchmark mode specified");
6235
6236 return (-1);
6237 }
6238
6239 if (attack_mode_chgd == 1)
6240 {
6241 if (attack_mode != ATTACK_MODE_BF)
6242 {
6243 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6244
6245 return (-1);
6246 }
6247 }
6248 }
6249
6250 if (skip != 0 && limit != 0)
6251 {
6252 limit += skip;
6253 }
6254
6255 if (keyspace == 1)
6256 {
6257 if (show == 1)
6258 {
6259 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6260
6261 return (-1);
6262 }
6263 else if (left == 1)
6264 {
6265 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6266
6267 return (-1);
6268 }
6269
6270 potfile_disable = 1;
6271
6272 restore_disable = 1;
6273
6274 restore = 0;
6275
6276 weak_hash_threshold = 0;
6277
6278 quiet = 1;
6279 }
6280
6281 if (remove_timer_chgd == 1)
6282 {
6283 if (remove == 0)
6284 {
6285 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6286
6287 return (-1);
6288 }
6289
6290 if (remove_timer < 1)
6291 {
6292 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6293
6294 return (-1);
6295 }
6296 }
6297
6298 if (loopback == 1)
6299 {
6300 if (attack_mode == ATTACK_MODE_BF)
6301 {
6302 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
6303
6304 return (-1);
6305 }
6306 else if (attack_mode == ATTACK_MODE_STRAIGHT)
6307 {
6308 if ((rp_files_cnt == 0) && (rp_gen == 0))
6309 {
6310 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6311
6312 return (-1);
6313 }
6314 }
6315 }
6316
6317 if (debug_mode > 0)
6318 {
6319 if (attack_mode != ATTACK_MODE_STRAIGHT)
6320 {
6321 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6322
6323 return (-1);
6324 }
6325
6326 if ((rp_files_cnt == 0) && (rp_gen == 0))
6327 {
6328 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6329
6330 return (-1);
6331 }
6332 }
6333
6334 if (debug_mode > 4)
6335 {
6336 log_error ("ERROR: Invalid debug-mode specified");
6337
6338 return (-1);
6339 }
6340
6341 if (debug_file != NULL)
6342 {
6343 if (debug_mode < 1)
6344 {
6345 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6346
6347 return (-1);
6348 }
6349 }
6350
6351 if (induction_dir != NULL)
6352 {
6353 if (attack_mode == ATTACK_MODE_BF)
6354 {
6355 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6356
6357 return (-1);
6358 }
6359 }
6360
6361 if (attack_mode != ATTACK_MODE_STRAIGHT)
6362 {
6363 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6364 {
6365 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6366
6367 return (-1);
6368 }
6369
6370 weak_hash_threshold = 0;
6371 }
6372
6373 /**
6374 * induction directory
6375 */
6376
6377 char *induction_directory = NULL;
6378
6379 if (attack_mode != ATTACK_MODE_BF)
6380 {
6381 if (induction_dir == NULL)
6382 {
6383 induction_directory = (char *) mymalloc (session_size);
6384
6385 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6386
6387 // create induction folder if it does not already exist
6388
6389 if (keyspace == 0)
6390 {
6391 if (rmdir (induction_directory) == -1)
6392 {
6393 if (errno == ENOENT)
6394 {
6395 // good, we can ignore
6396 }
6397 else if (errno == ENOTEMPTY)
6398 {
6399 char *induction_directory_mv = (char *) mymalloc (session_size);
6400
6401 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6402
6403 if (rename (induction_directory, induction_directory_mv) != 0)
6404 {
6405 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6406
6407 return (-1);
6408 }
6409 }
6410 else
6411 {
6412 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6413
6414 return (-1);
6415 }
6416 }
6417
6418 if (mkdir (induction_directory, 0700) == -1)
6419 {
6420 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6421
6422 return (-1);
6423 }
6424 }
6425 }
6426 else
6427 {
6428 induction_directory = induction_dir;
6429 }
6430 }
6431
6432 data.induction_directory = induction_directory;
6433
6434 /**
6435 * loopback
6436 */
6437
6438 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6439
6440 char *loopback_file = (char *) mymalloc (loopback_size);
6441
6442 /**
6443 * tuning db
6444 */
6445
6446 char tuning_db_file[256] = { 0 };
6447
6448 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6449
6450 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6451
6452 /**
6453 * outfile-check directory
6454 */
6455
6456 char *outfile_check_directory = NULL;
6457
6458 if (outfile_check_dir == NULL)
6459 {
6460 outfile_check_directory = (char *) mymalloc (session_size);
6461
6462 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6463 }
6464 else
6465 {
6466 outfile_check_directory = outfile_check_dir;
6467 }
6468
6469 data.outfile_check_directory = outfile_check_directory;
6470
6471 if (keyspace == 0)
6472 {
6473 struct stat outfile_check_stat;
6474
6475 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6476 {
6477 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6478
6479 if (is_dir == 0)
6480 {
6481 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6482
6483 return (-1);
6484 }
6485 }
6486 else if (outfile_check_dir == NULL)
6487 {
6488 if (mkdir (outfile_check_directory, 0700) == -1)
6489 {
6490 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6491
6492 return (-1);
6493 }
6494 }
6495 }
6496
6497 /**
6498 * special other stuff
6499 */
6500
6501 if (hash_mode == 9710)
6502 {
6503 outfile_format = 5;
6504 outfile_format_chgd = 1;
6505 }
6506
6507 if (hash_mode == 9810)
6508 {
6509 outfile_format = 5;
6510 outfile_format_chgd = 1;
6511 }
6512
6513 if (hash_mode == 10410)
6514 {
6515 outfile_format = 5;
6516 outfile_format_chgd = 1;
6517 }
6518
6519 /**
6520 * store stuff
6521 */
6522
6523 data.hash_mode = hash_mode;
6524 data.restore = restore;
6525 data.restore_timer = restore_timer;
6526 data.restore_disable = restore_disable;
6527 data.status = status;
6528 data.status_timer = status_timer;
6529 data.status_automat = status_automat;
6530 data.loopback = loopback;
6531 data.runtime = runtime;
6532 data.remove = remove;
6533 data.remove_timer = remove_timer;
6534 data.debug_mode = debug_mode;
6535 data.debug_file = debug_file;
6536 data.username = username;
6537 data.quiet = quiet;
6538 data.outfile = outfile;
6539 data.outfile_format = outfile_format;
6540 data.outfile_autohex = outfile_autohex;
6541 data.hex_charset = hex_charset;
6542 data.hex_salt = hex_salt;
6543 data.hex_wordlist = hex_wordlist;
6544 data.separator = separator;
6545 data.rp_files = rp_files;
6546 data.rp_files_cnt = rp_files_cnt;
6547 data.rp_gen = rp_gen;
6548 data.rp_gen_seed = rp_gen_seed;
6549 data.force = force;
6550 data.benchmark = benchmark;
6551 data.benchmark_repeats = benchmark_repeats;
6552 data.skip = skip;
6553 data.limit = limit;
6554 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6555 data.powertune_enable = powertune_enable;
6556 #endif
6557 data.logfile_disable = logfile_disable;
6558 data.truecrypt_keyfiles = truecrypt_keyfiles;
6559 data.scrypt_tmto = scrypt_tmto;
6560 data.workload_profile = workload_profile;
6561
6562 /**
6563 * cpu affinity
6564 */
6565
6566 if (cpu_affinity)
6567 {
6568 set_cpu_affinity (cpu_affinity);
6569 }
6570
6571 if (rp_gen_seed_chgd == 0)
6572 {
6573 srand (proc_start);
6574 }
6575 else
6576 {
6577 srand (rp_gen_seed);
6578 }
6579
6580 /**
6581 * logfile init
6582 */
6583
6584 if (logfile_disable == 0)
6585 {
6586 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6587
6588 char *logfile = (char *) mymalloc (logfile_size);
6589
6590 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6591
6592 data.logfile = logfile;
6593
6594 char *topid = logfile_generate_topid ();
6595
6596 data.topid = topid;
6597 }
6598
6599 // logfile_append() checks for logfile_disable internally to make it easier from here
6600
6601 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6602 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6603 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6604 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6605 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6606 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6607 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6608 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6609 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6610 #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));
6611
6612 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6613 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6614 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6615 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6616 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6617 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6618 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6619 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6620
6621 logfile_top_msg ("START");
6622
6623 logfile_top_uint (attack_mode);
6624 logfile_top_uint (attack_kern);
6625 logfile_top_uint (benchmark);
6626 logfile_top_uint (benchmark_repeats);
6627 logfile_top_uint (bitmap_min);
6628 logfile_top_uint (bitmap_max);
6629 logfile_top_uint (debug_mode);
6630 logfile_top_uint (force);
6631 logfile_top_uint (kernel_accel);
6632 logfile_top_uint (kernel_loops);
6633 logfile_top_uint (gpu_temp_disable);
6634 #ifdef HAVE_HWMON
6635 logfile_top_uint (gpu_temp_abort);
6636 logfile_top_uint (gpu_temp_retain);
6637 #endif
6638 logfile_top_uint (hash_mode);
6639 logfile_top_uint (hex_charset);
6640 logfile_top_uint (hex_salt);
6641 logfile_top_uint (hex_wordlist);
6642 logfile_top_uint (increment);
6643 logfile_top_uint (increment_max);
6644 logfile_top_uint (increment_min);
6645 logfile_top_uint (keyspace);
6646 logfile_top_uint (left);
6647 logfile_top_uint (logfile_disable);
6648 logfile_top_uint (loopback);
6649 logfile_top_uint (markov_classic);
6650 logfile_top_uint (markov_disable);
6651 logfile_top_uint (markov_threshold);
6652 logfile_top_uint (outfile_autohex);
6653 logfile_top_uint (outfile_check_timer);
6654 logfile_top_uint (outfile_format);
6655 logfile_top_uint (potfile_disable);
6656 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6657 logfile_top_uint (powertune_enable);
6658 #endif
6659 logfile_top_uint (scrypt_tmto);
6660 logfile_top_uint (quiet);
6661 logfile_top_uint (remove);
6662 logfile_top_uint (remove_timer);
6663 logfile_top_uint (restore);
6664 logfile_top_uint (restore_disable);
6665 logfile_top_uint (restore_timer);
6666 logfile_top_uint (rp_gen);
6667 logfile_top_uint (rp_gen_func_max);
6668 logfile_top_uint (rp_gen_func_min);
6669 logfile_top_uint (rp_gen_seed);
6670 logfile_top_uint (runtime);
6671 logfile_top_uint (segment_size);
6672 logfile_top_uint (show);
6673 logfile_top_uint (status);
6674 logfile_top_uint (status_automat);
6675 logfile_top_uint (status_timer);
6676 logfile_top_uint (usage);
6677 logfile_top_uint (username);
6678 logfile_top_uint (version);
6679 logfile_top_uint (weak_hash_threshold);
6680 logfile_top_uint (workload_profile);
6681 logfile_top_uint64 (limit);
6682 logfile_top_uint64 (skip);
6683 logfile_top_char (separator);
6684 logfile_top_string (cpu_affinity);
6685 logfile_top_string (custom_charset_1);
6686 logfile_top_string (custom_charset_2);
6687 logfile_top_string (custom_charset_3);
6688 logfile_top_string (custom_charset_4);
6689 logfile_top_string (debug_file);
6690 logfile_top_string (opencl_devices);
6691 logfile_top_string (opencl_platforms);
6692 logfile_top_string (opencl_device_types);
6693 logfile_top_uint (opencl_vector_width);
6694 logfile_top_string (induction_dir);
6695 logfile_top_string (markov_hcstat);
6696 logfile_top_string (outfile);
6697 logfile_top_string (outfile_check_dir);
6698 logfile_top_string (rule_buf_l);
6699 logfile_top_string (rule_buf_r);
6700 logfile_top_string (session);
6701 logfile_top_string (truecrypt_keyfiles);
6702
6703 /**
6704 * Init OpenCL library loader
6705 */
6706
6707 if (keyspace == 0)
6708 {
6709 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6710
6711 ocl_init (ocl);
6712
6713 data.ocl = ocl;
6714 }
6715
6716 /**
6717 * OpenCL platform selection
6718 */
6719
6720 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6721
6722 /**
6723 * OpenCL device selection
6724 */
6725
6726 u32 devices_filter = setup_devices_filter (opencl_devices);
6727
6728 /**
6729 * OpenCL device type selection
6730 */
6731
6732 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6733
6734 /**
6735 * benchmark
6736 */
6737
6738 if (benchmark == 1)
6739 {
6740 /**
6741 * disable useless stuff for benchmark
6742 */
6743
6744 status_timer = 0;
6745 restore_timer = 0;
6746 restore_disable = 1;
6747 potfile_disable = 1;
6748 weak_hash_threshold = 0;
6749 gpu_temp_disable = 1;
6750
6751 data.status_timer = status_timer;
6752 data.restore_timer = restore_timer;
6753 data.restore_disable = restore_disable;
6754
6755 /**
6756 * force attack mode to be bruteforce
6757 */
6758
6759 attack_mode = ATTACK_MODE_BF;
6760 attack_kern = ATTACK_KERN_BF;
6761
6762 if (workload_profile_chgd == 0)
6763 {
6764 workload_profile = 3;
6765
6766 data.workload_profile = workload_profile;
6767 }
6768 }
6769
6770 /**
6771 * config
6772 */
6773
6774 uint hash_type = 0;
6775 uint salt_type = 0;
6776 uint attack_exec = 0;
6777 uint opts_type = 0;
6778 uint kern_type = 0;
6779 uint dgst_size = 0;
6780 uint esalt_size = 0;
6781 uint opti_type = 0;
6782 uint dgst_pos0 = -1;
6783 uint dgst_pos1 = -1;
6784 uint dgst_pos2 = -1;
6785 uint dgst_pos3 = -1;
6786
6787 int (*parse_func) (char *, uint, hash_t *);
6788 int (*sort_by_digest) (const void *, const void *);
6789
6790 uint algorithm_pos = 0;
6791 uint algorithm_max = 1;
6792
6793 uint *algorithms = default_benchmark_algorithms;
6794
6795 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6796
6797 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6798 {
6799 /*
6800 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6801 * the following algos are skipped entirely
6802 */
6803
6804 if (algorithm_pos > 0)
6805 {
6806 local_free (rd);
6807
6808 rd = init_restore (argc, argv);
6809
6810 data.rd = rd;
6811 }
6812
6813 /**
6814 * update hash_mode in case of multihash benchmark
6815 */
6816
6817 if (benchmark == 1)
6818 {
6819 if (hash_mode_chgd == 0)
6820 {
6821 hash_mode = algorithms[algorithm_pos];
6822
6823 data.hash_mode = hash_mode;
6824 }
6825
6826 quiet = 1;
6827
6828 data.quiet = quiet;
6829 }
6830
6831 switch (hash_mode)
6832 {
6833 case 0: hash_type = HASH_TYPE_MD5;
6834 salt_type = SALT_TYPE_NONE;
6835 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6836 opts_type = OPTS_TYPE_PT_GENERATE_LE
6837 | OPTS_TYPE_PT_ADD80
6838 | OPTS_TYPE_PT_ADDBITS14;
6839 kern_type = KERN_TYPE_MD5;
6840 dgst_size = DGST_SIZE_4_4;
6841 parse_func = md5_parse_hash;
6842 sort_by_digest = sort_by_digest_4_4;
6843 opti_type = OPTI_TYPE_ZERO_BYTE
6844 | OPTI_TYPE_PRECOMPUTE_INIT
6845 | OPTI_TYPE_PRECOMPUTE_MERKLE
6846 | OPTI_TYPE_MEET_IN_MIDDLE
6847 | OPTI_TYPE_EARLY_SKIP
6848 | OPTI_TYPE_NOT_ITERATED
6849 | OPTI_TYPE_NOT_SALTED
6850 | OPTI_TYPE_RAW_HASH;
6851 dgst_pos0 = 0;
6852 dgst_pos1 = 3;
6853 dgst_pos2 = 2;
6854 dgst_pos3 = 1;
6855 break;
6856
6857 case 10: hash_type = HASH_TYPE_MD5;
6858 salt_type = SALT_TYPE_INTERN;
6859 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6860 opts_type = OPTS_TYPE_PT_GENERATE_LE
6861 | OPTS_TYPE_ST_ADD80
6862 | OPTS_TYPE_ST_ADDBITS14;
6863 kern_type = KERN_TYPE_MD5_PWSLT;
6864 dgst_size = DGST_SIZE_4_4;
6865 parse_func = md5s_parse_hash;
6866 sort_by_digest = sort_by_digest_4_4;
6867 opti_type = OPTI_TYPE_ZERO_BYTE
6868 | OPTI_TYPE_PRECOMPUTE_INIT
6869 | OPTI_TYPE_PRECOMPUTE_MERKLE
6870 | OPTI_TYPE_MEET_IN_MIDDLE
6871 | OPTI_TYPE_EARLY_SKIP
6872 | OPTI_TYPE_NOT_ITERATED
6873 | OPTI_TYPE_APPENDED_SALT
6874 | OPTI_TYPE_RAW_HASH;
6875 dgst_pos0 = 0;
6876 dgst_pos1 = 3;
6877 dgst_pos2 = 2;
6878 dgst_pos3 = 1;
6879 break;
6880
6881 case 11: hash_type = HASH_TYPE_MD5;
6882 salt_type = SALT_TYPE_INTERN;
6883 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6884 opts_type = OPTS_TYPE_PT_GENERATE_LE
6885 | OPTS_TYPE_ST_ADD80
6886 | OPTS_TYPE_ST_ADDBITS14;
6887 kern_type = KERN_TYPE_MD5_PWSLT;
6888 dgst_size = DGST_SIZE_4_4;
6889 parse_func = joomla_parse_hash;
6890 sort_by_digest = sort_by_digest_4_4;
6891 opti_type = OPTI_TYPE_ZERO_BYTE
6892 | OPTI_TYPE_PRECOMPUTE_INIT
6893 | OPTI_TYPE_PRECOMPUTE_MERKLE
6894 | OPTI_TYPE_MEET_IN_MIDDLE
6895 | OPTI_TYPE_EARLY_SKIP
6896 | OPTI_TYPE_NOT_ITERATED
6897 | OPTI_TYPE_APPENDED_SALT
6898 | OPTI_TYPE_RAW_HASH;
6899 dgst_pos0 = 0;
6900 dgst_pos1 = 3;
6901 dgst_pos2 = 2;
6902 dgst_pos3 = 1;
6903 break;
6904
6905 case 12: hash_type = HASH_TYPE_MD5;
6906 salt_type = SALT_TYPE_INTERN;
6907 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6908 opts_type = OPTS_TYPE_PT_GENERATE_LE
6909 | OPTS_TYPE_ST_ADD80
6910 | OPTS_TYPE_ST_ADDBITS14;
6911 kern_type = KERN_TYPE_MD5_PWSLT;
6912 dgst_size = DGST_SIZE_4_4;
6913 parse_func = postgresql_parse_hash;
6914 sort_by_digest = sort_by_digest_4_4;
6915 opti_type = OPTI_TYPE_ZERO_BYTE
6916 | OPTI_TYPE_PRECOMPUTE_INIT
6917 | OPTI_TYPE_PRECOMPUTE_MERKLE
6918 | OPTI_TYPE_MEET_IN_MIDDLE
6919 | OPTI_TYPE_EARLY_SKIP
6920 | OPTI_TYPE_NOT_ITERATED
6921 | OPTI_TYPE_APPENDED_SALT
6922 | OPTI_TYPE_RAW_HASH;
6923 dgst_pos0 = 0;
6924 dgst_pos1 = 3;
6925 dgst_pos2 = 2;
6926 dgst_pos3 = 1;
6927 break;
6928
6929 case 20: hash_type = HASH_TYPE_MD5;
6930 salt_type = SALT_TYPE_INTERN;
6931 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6932 opts_type = OPTS_TYPE_PT_GENERATE_LE
6933 | OPTS_TYPE_PT_ADD80
6934 | OPTS_TYPE_PT_ADDBITS14;
6935 kern_type = KERN_TYPE_MD5_SLTPW;
6936 dgst_size = DGST_SIZE_4_4;
6937 parse_func = md5s_parse_hash;
6938 sort_by_digest = sort_by_digest_4_4;
6939 opti_type = OPTI_TYPE_ZERO_BYTE
6940 | OPTI_TYPE_PRECOMPUTE_INIT
6941 | OPTI_TYPE_PRECOMPUTE_MERKLE
6942 | OPTI_TYPE_EARLY_SKIP
6943 | OPTI_TYPE_NOT_ITERATED
6944 | OPTI_TYPE_PREPENDED_SALT
6945 | OPTI_TYPE_RAW_HASH;
6946 dgst_pos0 = 0;
6947 dgst_pos1 = 3;
6948 dgst_pos2 = 2;
6949 dgst_pos3 = 1;
6950 break;
6951
6952 case 21: hash_type = HASH_TYPE_MD5;
6953 salt_type = SALT_TYPE_INTERN;
6954 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6955 opts_type = OPTS_TYPE_PT_GENERATE_LE
6956 | OPTS_TYPE_PT_ADD80
6957 | OPTS_TYPE_PT_ADDBITS14;
6958 kern_type = KERN_TYPE_MD5_SLTPW;
6959 dgst_size = DGST_SIZE_4_4;
6960 parse_func = osc_parse_hash;
6961 sort_by_digest = sort_by_digest_4_4;
6962 opti_type = OPTI_TYPE_ZERO_BYTE
6963 | OPTI_TYPE_PRECOMPUTE_INIT
6964 | OPTI_TYPE_PRECOMPUTE_MERKLE
6965 | OPTI_TYPE_EARLY_SKIP
6966 | OPTI_TYPE_NOT_ITERATED
6967 | OPTI_TYPE_PREPENDED_SALT
6968 | OPTI_TYPE_RAW_HASH;
6969 dgst_pos0 = 0;
6970 dgst_pos1 = 3;
6971 dgst_pos2 = 2;
6972 dgst_pos3 = 1;
6973 break;
6974
6975 case 22: hash_type = HASH_TYPE_MD5;
6976 salt_type = SALT_TYPE_EMBEDDED;
6977 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6978 opts_type = OPTS_TYPE_PT_GENERATE_LE
6979 | OPTS_TYPE_PT_ADD80
6980 | OPTS_TYPE_PT_ADDBITS14;
6981 kern_type = KERN_TYPE_MD5_SLTPW;
6982 dgst_size = DGST_SIZE_4_4;
6983 parse_func = netscreen_parse_hash;
6984 sort_by_digest = sort_by_digest_4_4;
6985 opti_type = OPTI_TYPE_ZERO_BYTE
6986 | OPTI_TYPE_PRECOMPUTE_INIT
6987 | OPTI_TYPE_PRECOMPUTE_MERKLE
6988 | OPTI_TYPE_EARLY_SKIP
6989 | OPTI_TYPE_NOT_ITERATED
6990 | OPTI_TYPE_PREPENDED_SALT
6991 | OPTI_TYPE_RAW_HASH;
6992 dgst_pos0 = 0;
6993 dgst_pos1 = 3;
6994 dgst_pos2 = 2;
6995 dgst_pos3 = 1;
6996 break;
6997
6998 case 23: hash_type = HASH_TYPE_MD5;
6999 salt_type = SALT_TYPE_EMBEDDED;
7000 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7001 opts_type = OPTS_TYPE_PT_GENERATE_LE
7002 | OPTS_TYPE_PT_ADD80
7003 | OPTS_TYPE_PT_ADDBITS14;
7004 kern_type = KERN_TYPE_MD5_SLTPW;
7005 dgst_size = DGST_SIZE_4_4;
7006 parse_func = skype_parse_hash;
7007 sort_by_digest = sort_by_digest_4_4;
7008 opti_type = OPTI_TYPE_ZERO_BYTE
7009 | OPTI_TYPE_PRECOMPUTE_INIT
7010 | OPTI_TYPE_PRECOMPUTE_MERKLE
7011 | OPTI_TYPE_EARLY_SKIP
7012 | OPTI_TYPE_NOT_ITERATED
7013 | OPTI_TYPE_PREPENDED_SALT
7014 | OPTI_TYPE_RAW_HASH;
7015 dgst_pos0 = 0;
7016 dgst_pos1 = 3;
7017 dgst_pos2 = 2;
7018 dgst_pos3 = 1;
7019 break;
7020
7021 case 30: hash_type = HASH_TYPE_MD5;
7022 salt_type = SALT_TYPE_INTERN;
7023 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7024 opts_type = OPTS_TYPE_PT_GENERATE_LE
7025 | OPTS_TYPE_PT_UNICODE
7026 | OPTS_TYPE_ST_ADD80
7027 | OPTS_TYPE_ST_ADDBITS14;
7028 kern_type = KERN_TYPE_MD5_PWUSLT;
7029 dgst_size = DGST_SIZE_4_4;
7030 parse_func = md5s_parse_hash;
7031 sort_by_digest = sort_by_digest_4_4;
7032 opti_type = OPTI_TYPE_ZERO_BYTE
7033 | OPTI_TYPE_PRECOMPUTE_INIT
7034 | OPTI_TYPE_PRECOMPUTE_MERKLE
7035 | OPTI_TYPE_MEET_IN_MIDDLE
7036 | OPTI_TYPE_EARLY_SKIP
7037 | OPTI_TYPE_NOT_ITERATED
7038 | OPTI_TYPE_APPENDED_SALT
7039 | OPTI_TYPE_RAW_HASH;
7040 dgst_pos0 = 0;
7041 dgst_pos1 = 3;
7042 dgst_pos2 = 2;
7043 dgst_pos3 = 1;
7044 break;
7045
7046 case 40: hash_type = HASH_TYPE_MD5;
7047 salt_type = SALT_TYPE_INTERN;
7048 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7049 opts_type = OPTS_TYPE_PT_GENERATE_LE
7050 | OPTS_TYPE_PT_ADD80
7051 | OPTS_TYPE_PT_ADDBITS14
7052 | OPTS_TYPE_PT_UNICODE;
7053 kern_type = KERN_TYPE_MD5_SLTPWU;
7054 dgst_size = DGST_SIZE_4_4;
7055 parse_func = md5s_parse_hash;
7056 sort_by_digest = sort_by_digest_4_4;
7057 opti_type = OPTI_TYPE_ZERO_BYTE
7058 | OPTI_TYPE_PRECOMPUTE_INIT
7059 | OPTI_TYPE_PRECOMPUTE_MERKLE
7060 | OPTI_TYPE_EARLY_SKIP
7061 | OPTI_TYPE_NOT_ITERATED
7062 | OPTI_TYPE_PREPENDED_SALT
7063 | OPTI_TYPE_RAW_HASH;
7064 dgst_pos0 = 0;
7065 dgst_pos1 = 3;
7066 dgst_pos2 = 2;
7067 dgst_pos3 = 1;
7068 break;
7069
7070 case 50: hash_type = HASH_TYPE_MD5;
7071 salt_type = SALT_TYPE_INTERN;
7072 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7073 opts_type = OPTS_TYPE_PT_GENERATE_LE
7074 | OPTS_TYPE_ST_ADD80
7075 | OPTS_TYPE_ST_ADDBITS14;
7076 kern_type = KERN_TYPE_HMACMD5_PW;
7077 dgst_size = DGST_SIZE_4_4;
7078 parse_func = hmacmd5_parse_hash;
7079 sort_by_digest = sort_by_digest_4_4;
7080 opti_type = OPTI_TYPE_ZERO_BYTE
7081 | OPTI_TYPE_NOT_ITERATED;
7082 dgst_pos0 = 0;
7083 dgst_pos1 = 3;
7084 dgst_pos2 = 2;
7085 dgst_pos3 = 1;
7086 break;
7087
7088 case 60: hash_type = HASH_TYPE_MD5;
7089 salt_type = SALT_TYPE_INTERN;
7090 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7091 opts_type = OPTS_TYPE_PT_GENERATE_LE
7092 | OPTS_TYPE_PT_ADD80
7093 | OPTS_TYPE_PT_ADDBITS14;
7094 kern_type = KERN_TYPE_HMACMD5_SLT;
7095 dgst_size = DGST_SIZE_4_4;
7096 parse_func = hmacmd5_parse_hash;
7097 sort_by_digest = sort_by_digest_4_4;
7098 opti_type = OPTI_TYPE_ZERO_BYTE
7099 | OPTI_TYPE_NOT_ITERATED;
7100 dgst_pos0 = 0;
7101 dgst_pos1 = 3;
7102 dgst_pos2 = 2;
7103 dgst_pos3 = 1;
7104 break;
7105
7106 case 100: hash_type = HASH_TYPE_SHA1;
7107 salt_type = SALT_TYPE_NONE;
7108 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7109 opts_type = OPTS_TYPE_PT_GENERATE_BE
7110 | OPTS_TYPE_PT_ADD80
7111 | OPTS_TYPE_PT_ADDBITS15;
7112 kern_type = KERN_TYPE_SHA1;
7113 dgst_size = DGST_SIZE_4_5;
7114 parse_func = sha1_parse_hash;
7115 sort_by_digest = sort_by_digest_4_5;
7116 opti_type = OPTI_TYPE_ZERO_BYTE
7117 | OPTI_TYPE_PRECOMPUTE_INIT
7118 | OPTI_TYPE_PRECOMPUTE_MERKLE
7119 | OPTI_TYPE_EARLY_SKIP
7120 | OPTI_TYPE_NOT_ITERATED
7121 | OPTI_TYPE_NOT_SALTED
7122 | OPTI_TYPE_RAW_HASH;
7123 dgst_pos0 = 3;
7124 dgst_pos1 = 4;
7125 dgst_pos2 = 2;
7126 dgst_pos3 = 1;
7127 break;
7128
7129 case 101: hash_type = HASH_TYPE_SHA1;
7130 salt_type = SALT_TYPE_NONE;
7131 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7132 opts_type = OPTS_TYPE_PT_GENERATE_BE
7133 | OPTS_TYPE_PT_ADD80
7134 | OPTS_TYPE_PT_ADDBITS15;
7135 kern_type = KERN_TYPE_SHA1;
7136 dgst_size = DGST_SIZE_4_5;
7137 parse_func = sha1b64_parse_hash;
7138 sort_by_digest = sort_by_digest_4_5;
7139 opti_type = OPTI_TYPE_ZERO_BYTE
7140 | OPTI_TYPE_PRECOMPUTE_INIT
7141 | OPTI_TYPE_PRECOMPUTE_MERKLE
7142 | OPTI_TYPE_EARLY_SKIP
7143 | OPTI_TYPE_NOT_ITERATED
7144 | OPTI_TYPE_NOT_SALTED
7145 | OPTI_TYPE_RAW_HASH;
7146 dgst_pos0 = 3;
7147 dgst_pos1 = 4;
7148 dgst_pos2 = 2;
7149 dgst_pos3 = 1;
7150 break;
7151
7152 case 110: hash_type = HASH_TYPE_SHA1;
7153 salt_type = SALT_TYPE_INTERN;
7154 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7155 opts_type = OPTS_TYPE_PT_GENERATE_BE
7156 | OPTS_TYPE_ST_ADD80
7157 | OPTS_TYPE_ST_ADDBITS15;
7158 kern_type = KERN_TYPE_SHA1_PWSLT;
7159 dgst_size = DGST_SIZE_4_5;
7160 parse_func = sha1s_parse_hash;
7161 sort_by_digest = sort_by_digest_4_5;
7162 opti_type = OPTI_TYPE_ZERO_BYTE
7163 | OPTI_TYPE_PRECOMPUTE_INIT
7164 | OPTI_TYPE_PRECOMPUTE_MERKLE
7165 | OPTI_TYPE_EARLY_SKIP
7166 | OPTI_TYPE_NOT_ITERATED
7167 | OPTI_TYPE_APPENDED_SALT
7168 | OPTI_TYPE_RAW_HASH;
7169 dgst_pos0 = 3;
7170 dgst_pos1 = 4;
7171 dgst_pos2 = 2;
7172 dgst_pos3 = 1;
7173 break;
7174
7175 case 111: hash_type = HASH_TYPE_SHA1;
7176 salt_type = SALT_TYPE_EMBEDDED;
7177 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7178 opts_type = OPTS_TYPE_PT_GENERATE_BE
7179 | OPTS_TYPE_ST_ADD80
7180 | OPTS_TYPE_ST_ADDBITS15;
7181 kern_type = KERN_TYPE_SHA1_PWSLT;
7182 dgst_size = DGST_SIZE_4_5;
7183 parse_func = sha1b64s_parse_hash;
7184 sort_by_digest = sort_by_digest_4_5;
7185 opti_type = OPTI_TYPE_ZERO_BYTE
7186 | OPTI_TYPE_PRECOMPUTE_INIT
7187 | OPTI_TYPE_PRECOMPUTE_MERKLE
7188 | OPTI_TYPE_EARLY_SKIP
7189 | OPTI_TYPE_NOT_ITERATED
7190 | OPTI_TYPE_APPENDED_SALT
7191 | OPTI_TYPE_RAW_HASH;
7192 dgst_pos0 = 3;
7193 dgst_pos1 = 4;
7194 dgst_pos2 = 2;
7195 dgst_pos3 = 1;
7196 break;
7197
7198 case 112: hash_type = HASH_TYPE_SHA1;
7199 salt_type = SALT_TYPE_INTERN;
7200 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7201 opts_type = OPTS_TYPE_PT_GENERATE_BE
7202 | OPTS_TYPE_ST_ADD80
7203 | OPTS_TYPE_ST_ADDBITS15
7204 | OPTS_TYPE_ST_HEX;
7205 kern_type = KERN_TYPE_SHA1_PWSLT;
7206 dgst_size = DGST_SIZE_4_5;
7207 parse_func = oracles_parse_hash;
7208 sort_by_digest = sort_by_digest_4_5;
7209 opti_type = OPTI_TYPE_ZERO_BYTE
7210 | OPTI_TYPE_PRECOMPUTE_INIT
7211 | OPTI_TYPE_PRECOMPUTE_MERKLE
7212 | OPTI_TYPE_EARLY_SKIP
7213 | OPTI_TYPE_NOT_ITERATED
7214 | OPTI_TYPE_APPENDED_SALT
7215 | OPTI_TYPE_RAW_HASH;
7216 dgst_pos0 = 3;
7217 dgst_pos1 = 4;
7218 dgst_pos2 = 2;
7219 dgst_pos3 = 1;
7220 break;
7221
7222 case 120: hash_type = HASH_TYPE_SHA1;
7223 salt_type = SALT_TYPE_INTERN;
7224 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7225 opts_type = OPTS_TYPE_PT_GENERATE_BE
7226 | OPTS_TYPE_PT_ADD80
7227 | OPTS_TYPE_PT_ADDBITS15;
7228 kern_type = KERN_TYPE_SHA1_SLTPW;
7229 dgst_size = DGST_SIZE_4_5;
7230 parse_func = sha1s_parse_hash;
7231 sort_by_digest = sort_by_digest_4_5;
7232 opti_type = OPTI_TYPE_ZERO_BYTE
7233 | OPTI_TYPE_PRECOMPUTE_INIT
7234 | OPTI_TYPE_PRECOMPUTE_MERKLE
7235 | OPTI_TYPE_EARLY_SKIP
7236 | OPTI_TYPE_NOT_ITERATED
7237 | OPTI_TYPE_PREPENDED_SALT
7238 | OPTI_TYPE_RAW_HASH;
7239 dgst_pos0 = 3;
7240 dgst_pos1 = 4;
7241 dgst_pos2 = 2;
7242 dgst_pos3 = 1;
7243 break;
7244
7245 case 121: hash_type = HASH_TYPE_SHA1;
7246 salt_type = SALT_TYPE_INTERN;
7247 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7248 opts_type = OPTS_TYPE_PT_GENERATE_BE
7249 | OPTS_TYPE_PT_ADD80
7250 | OPTS_TYPE_PT_ADDBITS15
7251 | OPTS_TYPE_ST_LOWER;
7252 kern_type = KERN_TYPE_SHA1_SLTPW;
7253 dgst_size = DGST_SIZE_4_5;
7254 parse_func = smf_parse_hash;
7255 sort_by_digest = sort_by_digest_4_5;
7256 opti_type = OPTI_TYPE_ZERO_BYTE
7257 | OPTI_TYPE_PRECOMPUTE_INIT
7258 | OPTI_TYPE_PRECOMPUTE_MERKLE
7259 | OPTI_TYPE_EARLY_SKIP
7260 | OPTI_TYPE_NOT_ITERATED
7261 | OPTI_TYPE_PREPENDED_SALT
7262 | OPTI_TYPE_RAW_HASH;
7263 dgst_pos0 = 3;
7264 dgst_pos1 = 4;
7265 dgst_pos2 = 2;
7266 dgst_pos3 = 1;
7267 break;
7268
7269 case 122: hash_type = HASH_TYPE_SHA1;
7270 salt_type = SALT_TYPE_EMBEDDED;
7271 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7272 opts_type = OPTS_TYPE_PT_GENERATE_BE
7273 | OPTS_TYPE_PT_ADD80
7274 | OPTS_TYPE_PT_ADDBITS15
7275 | OPTS_TYPE_ST_HEX;
7276 kern_type = KERN_TYPE_SHA1_SLTPW;
7277 dgst_size = DGST_SIZE_4_5;
7278 parse_func = osx1_parse_hash;
7279 sort_by_digest = sort_by_digest_4_5;
7280 opti_type = OPTI_TYPE_ZERO_BYTE
7281 | OPTI_TYPE_PRECOMPUTE_INIT
7282 | OPTI_TYPE_PRECOMPUTE_MERKLE
7283 | OPTI_TYPE_EARLY_SKIP
7284 | OPTI_TYPE_NOT_ITERATED
7285 | OPTI_TYPE_PREPENDED_SALT
7286 | OPTI_TYPE_RAW_HASH;
7287 dgst_pos0 = 3;
7288 dgst_pos1 = 4;
7289 dgst_pos2 = 2;
7290 dgst_pos3 = 1;
7291 break;
7292
7293 case 124: hash_type = HASH_TYPE_SHA1;
7294 salt_type = SALT_TYPE_EMBEDDED;
7295 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7296 opts_type = OPTS_TYPE_PT_GENERATE_BE
7297 | OPTS_TYPE_PT_ADD80
7298 | OPTS_TYPE_PT_ADDBITS15;
7299 kern_type = KERN_TYPE_SHA1_SLTPW;
7300 dgst_size = DGST_SIZE_4_5;
7301 parse_func = djangosha1_parse_hash;
7302 sort_by_digest = sort_by_digest_4_5;
7303 opti_type = OPTI_TYPE_ZERO_BYTE
7304 | OPTI_TYPE_PRECOMPUTE_INIT
7305 | OPTI_TYPE_PRECOMPUTE_MERKLE
7306 | OPTI_TYPE_EARLY_SKIP
7307 | OPTI_TYPE_NOT_ITERATED
7308 | OPTI_TYPE_PREPENDED_SALT
7309 | OPTI_TYPE_RAW_HASH;
7310 dgst_pos0 = 3;
7311 dgst_pos1 = 4;
7312 dgst_pos2 = 2;
7313 dgst_pos3 = 1;
7314 break;
7315
7316 case 130: hash_type = HASH_TYPE_SHA1;
7317 salt_type = SALT_TYPE_INTERN;
7318 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7319 opts_type = OPTS_TYPE_PT_GENERATE_BE
7320 | OPTS_TYPE_PT_UNICODE
7321 | OPTS_TYPE_ST_ADD80
7322 | OPTS_TYPE_ST_ADDBITS15;
7323 kern_type = KERN_TYPE_SHA1_PWUSLT;
7324 dgst_size = DGST_SIZE_4_5;
7325 parse_func = sha1s_parse_hash;
7326 sort_by_digest = sort_by_digest_4_5;
7327 opti_type = OPTI_TYPE_ZERO_BYTE
7328 | OPTI_TYPE_PRECOMPUTE_INIT
7329 | OPTI_TYPE_PRECOMPUTE_MERKLE
7330 | OPTI_TYPE_EARLY_SKIP
7331 | OPTI_TYPE_NOT_ITERATED
7332 | OPTI_TYPE_APPENDED_SALT
7333 | OPTI_TYPE_RAW_HASH;
7334 dgst_pos0 = 3;
7335 dgst_pos1 = 4;
7336 dgst_pos2 = 2;
7337 dgst_pos3 = 1;
7338 break;
7339
7340 case 131: hash_type = HASH_TYPE_SHA1;
7341 salt_type = SALT_TYPE_EMBEDDED;
7342 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7343 opts_type = OPTS_TYPE_PT_GENERATE_BE
7344 | OPTS_TYPE_PT_UNICODE
7345 | OPTS_TYPE_PT_UPPER
7346 | OPTS_TYPE_ST_ADD80
7347 | OPTS_TYPE_ST_ADDBITS15
7348 | OPTS_TYPE_ST_HEX;
7349 kern_type = KERN_TYPE_SHA1_PWUSLT;
7350 dgst_size = DGST_SIZE_4_5;
7351 parse_func = mssql2000_parse_hash;
7352 sort_by_digest = sort_by_digest_4_5;
7353 opti_type = OPTI_TYPE_ZERO_BYTE
7354 | OPTI_TYPE_PRECOMPUTE_INIT
7355 | OPTI_TYPE_PRECOMPUTE_MERKLE
7356 | OPTI_TYPE_EARLY_SKIP
7357 | OPTI_TYPE_NOT_ITERATED
7358 | OPTI_TYPE_APPENDED_SALT
7359 | OPTI_TYPE_RAW_HASH;
7360 dgst_pos0 = 3;
7361 dgst_pos1 = 4;
7362 dgst_pos2 = 2;
7363 dgst_pos3 = 1;
7364 break;
7365
7366 case 132: hash_type = HASH_TYPE_SHA1;
7367 salt_type = SALT_TYPE_EMBEDDED;
7368 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7369 opts_type = OPTS_TYPE_PT_GENERATE_BE
7370 | OPTS_TYPE_PT_UNICODE
7371 | OPTS_TYPE_ST_ADD80
7372 | OPTS_TYPE_ST_ADDBITS15
7373 | OPTS_TYPE_ST_HEX;
7374 kern_type = KERN_TYPE_SHA1_PWUSLT;
7375 dgst_size = DGST_SIZE_4_5;
7376 parse_func = mssql2005_parse_hash;
7377 sort_by_digest = sort_by_digest_4_5;
7378 opti_type = OPTI_TYPE_ZERO_BYTE
7379 | OPTI_TYPE_PRECOMPUTE_INIT
7380 | OPTI_TYPE_PRECOMPUTE_MERKLE
7381 | OPTI_TYPE_EARLY_SKIP
7382 | OPTI_TYPE_NOT_ITERATED
7383 | OPTI_TYPE_APPENDED_SALT
7384 | OPTI_TYPE_RAW_HASH;
7385 dgst_pos0 = 3;
7386 dgst_pos1 = 4;
7387 dgst_pos2 = 2;
7388 dgst_pos3 = 1;
7389 break;
7390
7391 case 133: hash_type = HASH_TYPE_SHA1;
7392 salt_type = SALT_TYPE_EMBEDDED;
7393 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7394 opts_type = OPTS_TYPE_PT_GENERATE_BE
7395 | OPTS_TYPE_PT_UNICODE
7396 | OPTS_TYPE_ST_ADD80
7397 | OPTS_TYPE_ST_ADDBITS15;
7398 kern_type = KERN_TYPE_SHA1_PWUSLT;
7399 dgst_size = DGST_SIZE_4_5;
7400 parse_func = peoplesoft_parse_hash;
7401 sort_by_digest = sort_by_digest_4_5;
7402 opti_type = OPTI_TYPE_ZERO_BYTE
7403 | OPTI_TYPE_PRECOMPUTE_INIT
7404 | OPTI_TYPE_PRECOMPUTE_MERKLE
7405 | OPTI_TYPE_EARLY_SKIP
7406 | OPTI_TYPE_NOT_ITERATED
7407 | OPTI_TYPE_APPENDED_SALT
7408 | OPTI_TYPE_RAW_HASH;
7409 dgst_pos0 = 3;
7410 dgst_pos1 = 4;
7411 dgst_pos2 = 2;
7412 dgst_pos3 = 1;
7413 break;
7414
7415 case 140: hash_type = HASH_TYPE_SHA1;
7416 salt_type = SALT_TYPE_INTERN;
7417 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7418 opts_type = OPTS_TYPE_PT_GENERATE_BE
7419 | OPTS_TYPE_PT_ADD80
7420 | OPTS_TYPE_PT_ADDBITS15
7421 | OPTS_TYPE_PT_UNICODE;
7422 kern_type = KERN_TYPE_SHA1_SLTPWU;
7423 dgst_size = DGST_SIZE_4_5;
7424 parse_func = sha1s_parse_hash;
7425 sort_by_digest = sort_by_digest_4_5;
7426 opti_type = OPTI_TYPE_ZERO_BYTE
7427 | OPTI_TYPE_PRECOMPUTE_INIT
7428 | OPTI_TYPE_PRECOMPUTE_MERKLE
7429 | OPTI_TYPE_EARLY_SKIP
7430 | OPTI_TYPE_NOT_ITERATED
7431 | OPTI_TYPE_PREPENDED_SALT
7432 | OPTI_TYPE_RAW_HASH;
7433 dgst_pos0 = 3;
7434 dgst_pos1 = 4;
7435 dgst_pos2 = 2;
7436 dgst_pos3 = 1;
7437 break;
7438
7439 case 141: hash_type = HASH_TYPE_SHA1;
7440 salt_type = SALT_TYPE_EMBEDDED;
7441 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7442 opts_type = OPTS_TYPE_PT_GENERATE_BE
7443 | OPTS_TYPE_PT_ADD80
7444 | OPTS_TYPE_PT_ADDBITS15
7445 | OPTS_TYPE_PT_UNICODE
7446 | OPTS_TYPE_ST_BASE64;
7447 kern_type = KERN_TYPE_SHA1_SLTPWU;
7448 dgst_size = DGST_SIZE_4_5;
7449 parse_func = episerver_parse_hash;
7450 sort_by_digest = sort_by_digest_4_5;
7451 opti_type = OPTI_TYPE_ZERO_BYTE
7452 | OPTI_TYPE_PRECOMPUTE_INIT
7453 | OPTI_TYPE_PRECOMPUTE_MERKLE
7454 | OPTI_TYPE_EARLY_SKIP
7455 | OPTI_TYPE_NOT_ITERATED
7456 | OPTI_TYPE_PREPENDED_SALT
7457 | OPTI_TYPE_RAW_HASH;
7458 dgst_pos0 = 3;
7459 dgst_pos1 = 4;
7460 dgst_pos2 = 2;
7461 dgst_pos3 = 1;
7462 break;
7463
7464 case 150: hash_type = HASH_TYPE_SHA1;
7465 salt_type = SALT_TYPE_INTERN;
7466 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7467 opts_type = OPTS_TYPE_PT_GENERATE_BE
7468 | OPTS_TYPE_ST_ADD80
7469 | OPTS_TYPE_ST_ADDBITS15;
7470 kern_type = KERN_TYPE_HMACSHA1_PW;
7471 dgst_size = DGST_SIZE_4_5;
7472 parse_func = hmacsha1_parse_hash;
7473 sort_by_digest = sort_by_digest_4_5;
7474 opti_type = OPTI_TYPE_ZERO_BYTE
7475 | OPTI_TYPE_NOT_ITERATED;
7476 dgst_pos0 = 3;
7477 dgst_pos1 = 4;
7478 dgst_pos2 = 2;
7479 dgst_pos3 = 1;
7480 break;
7481
7482 case 160: hash_type = HASH_TYPE_SHA1;
7483 salt_type = SALT_TYPE_INTERN;
7484 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7485 opts_type = OPTS_TYPE_PT_GENERATE_BE
7486 | OPTS_TYPE_PT_ADD80
7487 | OPTS_TYPE_PT_ADDBITS15;
7488 kern_type = KERN_TYPE_HMACSHA1_SLT;
7489 dgst_size = DGST_SIZE_4_5;
7490 parse_func = hmacsha1_parse_hash;
7491 sort_by_digest = sort_by_digest_4_5;
7492 opti_type = OPTI_TYPE_ZERO_BYTE
7493 | OPTI_TYPE_NOT_ITERATED;
7494 dgst_pos0 = 3;
7495 dgst_pos1 = 4;
7496 dgst_pos2 = 2;
7497 dgst_pos3 = 1;
7498 break;
7499
7500 case 190: hash_type = HASH_TYPE_SHA1;
7501 salt_type = SALT_TYPE_NONE;
7502 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7503 opts_type = OPTS_TYPE_PT_GENERATE_BE
7504 | OPTS_TYPE_PT_ADD80
7505 | OPTS_TYPE_PT_ADDBITS15;
7506 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7507 dgst_size = DGST_SIZE_4_5;
7508 parse_func = sha1linkedin_parse_hash;
7509 sort_by_digest = sort_by_digest_4_5;
7510 opti_type = OPTI_TYPE_ZERO_BYTE
7511 | OPTI_TYPE_PRECOMPUTE_INIT
7512 | OPTI_TYPE_EARLY_SKIP
7513 | OPTI_TYPE_NOT_ITERATED
7514 | OPTI_TYPE_NOT_SALTED;
7515 dgst_pos0 = 0;
7516 dgst_pos1 = 4;
7517 dgst_pos2 = 3;
7518 dgst_pos3 = 2;
7519 break;
7520
7521 case 200: hash_type = HASH_TYPE_MYSQL;
7522 salt_type = SALT_TYPE_NONE;
7523 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7524 opts_type = 0;
7525 kern_type = KERN_TYPE_MYSQL;
7526 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7527 parse_func = mysql323_parse_hash;
7528 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7529 opti_type = OPTI_TYPE_ZERO_BYTE;
7530 dgst_pos0 = 0;
7531 dgst_pos1 = 1;
7532 dgst_pos2 = 2;
7533 dgst_pos3 = 3;
7534 break;
7535
7536 case 300: hash_type = HASH_TYPE_SHA1;
7537 salt_type = SALT_TYPE_NONE;
7538 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7539 opts_type = OPTS_TYPE_PT_GENERATE_BE
7540 | OPTS_TYPE_PT_ADD80
7541 | OPTS_TYPE_PT_ADDBITS15;
7542 kern_type = KERN_TYPE_MYSQL41;
7543 dgst_size = DGST_SIZE_4_5;
7544 parse_func = sha1_parse_hash;
7545 sort_by_digest = sort_by_digest_4_5;
7546 opti_type = OPTI_TYPE_ZERO_BYTE
7547 | OPTI_TYPE_PRECOMPUTE_INIT
7548 | OPTI_TYPE_PRECOMPUTE_MERKLE
7549 | OPTI_TYPE_EARLY_SKIP
7550 | OPTI_TYPE_NOT_ITERATED
7551 | OPTI_TYPE_NOT_SALTED;
7552 dgst_pos0 = 3;
7553 dgst_pos1 = 4;
7554 dgst_pos2 = 2;
7555 dgst_pos3 = 1;
7556 break;
7557
7558 case 400: hash_type = HASH_TYPE_MD5;
7559 salt_type = SALT_TYPE_EMBEDDED;
7560 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7561 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7562 kern_type = KERN_TYPE_PHPASS;
7563 dgst_size = DGST_SIZE_4_4;
7564 parse_func = phpass_parse_hash;
7565 sort_by_digest = sort_by_digest_4_4;
7566 opti_type = OPTI_TYPE_ZERO_BYTE;
7567 dgst_pos0 = 0;
7568 dgst_pos1 = 1;
7569 dgst_pos2 = 2;
7570 dgst_pos3 = 3;
7571 break;
7572
7573 case 500: hash_type = HASH_TYPE_MD5;
7574 salt_type = SALT_TYPE_EMBEDDED;
7575 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7576 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7577 kern_type = KERN_TYPE_MD5CRYPT;
7578 dgst_size = DGST_SIZE_4_4;
7579 parse_func = md5crypt_parse_hash;
7580 sort_by_digest = sort_by_digest_4_4;
7581 opti_type = OPTI_TYPE_ZERO_BYTE;
7582 dgst_pos0 = 0;
7583 dgst_pos1 = 1;
7584 dgst_pos2 = 2;
7585 dgst_pos3 = 3;
7586 break;
7587
7588 case 501: hash_type = HASH_TYPE_MD5;
7589 salt_type = SALT_TYPE_EMBEDDED;
7590 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7591 opts_type = OPTS_TYPE_PT_GENERATE_LE
7592 | OPTS_TYPE_HASH_COPY;
7593 kern_type = KERN_TYPE_MD5CRYPT;
7594 dgst_size = DGST_SIZE_4_4;
7595 parse_func = juniper_parse_hash;
7596 sort_by_digest = sort_by_digest_4_4;
7597 opti_type = OPTI_TYPE_ZERO_BYTE;
7598 dgst_pos0 = 0;
7599 dgst_pos1 = 1;
7600 dgst_pos2 = 2;
7601 dgst_pos3 = 3;
7602 break;
7603
7604 case 900: hash_type = HASH_TYPE_MD4;
7605 salt_type = SALT_TYPE_NONE;
7606 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7607 opts_type = OPTS_TYPE_PT_GENERATE_LE
7608 | OPTS_TYPE_PT_ADD80
7609 | OPTS_TYPE_PT_ADDBITS14;
7610 kern_type = KERN_TYPE_MD4;
7611 dgst_size = DGST_SIZE_4_4;
7612 parse_func = md4_parse_hash;
7613 sort_by_digest = sort_by_digest_4_4;
7614 opti_type = OPTI_TYPE_ZERO_BYTE
7615 | OPTI_TYPE_PRECOMPUTE_INIT
7616 | OPTI_TYPE_PRECOMPUTE_MERKLE
7617 | OPTI_TYPE_MEET_IN_MIDDLE
7618 | OPTI_TYPE_EARLY_SKIP
7619 | OPTI_TYPE_NOT_ITERATED
7620 | OPTI_TYPE_NOT_SALTED
7621 | OPTI_TYPE_RAW_HASH;
7622 dgst_pos0 = 0;
7623 dgst_pos1 = 3;
7624 dgst_pos2 = 2;
7625 dgst_pos3 = 1;
7626 break;
7627
7628 case 1000: hash_type = HASH_TYPE_MD4;
7629 salt_type = SALT_TYPE_NONE;
7630 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7631 opts_type = OPTS_TYPE_PT_GENERATE_LE
7632 | OPTS_TYPE_PT_ADD80
7633 | OPTS_TYPE_PT_ADDBITS14
7634 | OPTS_TYPE_PT_UNICODE;
7635 kern_type = KERN_TYPE_MD4_PWU;
7636 dgst_size = DGST_SIZE_4_4;
7637 parse_func = md4_parse_hash;
7638 sort_by_digest = sort_by_digest_4_4;
7639 opti_type = OPTI_TYPE_ZERO_BYTE
7640 | OPTI_TYPE_PRECOMPUTE_INIT
7641 | OPTI_TYPE_PRECOMPUTE_MERKLE
7642 | OPTI_TYPE_MEET_IN_MIDDLE
7643 | OPTI_TYPE_EARLY_SKIP
7644 | OPTI_TYPE_NOT_ITERATED
7645 | OPTI_TYPE_NOT_SALTED
7646 | OPTI_TYPE_RAW_HASH;
7647 dgst_pos0 = 0;
7648 dgst_pos1 = 3;
7649 dgst_pos2 = 2;
7650 dgst_pos3 = 1;
7651 break;
7652
7653 case 1100: hash_type = HASH_TYPE_MD4;
7654 salt_type = SALT_TYPE_INTERN;
7655 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7656 opts_type = OPTS_TYPE_PT_GENERATE_LE
7657 | OPTS_TYPE_PT_ADD80
7658 | OPTS_TYPE_PT_ADDBITS14
7659 | OPTS_TYPE_PT_UNICODE
7660 | OPTS_TYPE_ST_ADD80
7661 | OPTS_TYPE_ST_UNICODE
7662 | OPTS_TYPE_ST_LOWER;
7663 kern_type = KERN_TYPE_MD44_PWUSLT;
7664 dgst_size = DGST_SIZE_4_4;
7665 parse_func = dcc_parse_hash;
7666 sort_by_digest = sort_by_digest_4_4;
7667 opti_type = OPTI_TYPE_ZERO_BYTE
7668 | OPTI_TYPE_PRECOMPUTE_INIT
7669 | OPTI_TYPE_PRECOMPUTE_MERKLE
7670 | OPTI_TYPE_EARLY_SKIP
7671 | OPTI_TYPE_NOT_ITERATED;
7672 dgst_pos0 = 0;
7673 dgst_pos1 = 3;
7674 dgst_pos2 = 2;
7675 dgst_pos3 = 1;
7676 break;
7677
7678 case 1400: hash_type = HASH_TYPE_SHA256;
7679 salt_type = SALT_TYPE_NONE;
7680 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7681 opts_type = OPTS_TYPE_PT_GENERATE_BE
7682 | OPTS_TYPE_PT_ADD80
7683 | OPTS_TYPE_PT_ADDBITS15;
7684 kern_type = KERN_TYPE_SHA256;
7685 dgst_size = DGST_SIZE_4_8;
7686 parse_func = sha256_parse_hash;
7687 sort_by_digest = sort_by_digest_4_8;
7688 opti_type = OPTI_TYPE_ZERO_BYTE
7689 | OPTI_TYPE_PRECOMPUTE_INIT
7690 | OPTI_TYPE_PRECOMPUTE_MERKLE
7691 | OPTI_TYPE_EARLY_SKIP
7692 | OPTI_TYPE_NOT_ITERATED
7693 | OPTI_TYPE_NOT_SALTED
7694 | OPTI_TYPE_RAW_HASH;
7695 dgst_pos0 = 3;
7696 dgst_pos1 = 7;
7697 dgst_pos2 = 2;
7698 dgst_pos3 = 6;
7699 break;
7700
7701 case 1410: hash_type = HASH_TYPE_SHA256;
7702 salt_type = SALT_TYPE_INTERN;
7703 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7704 opts_type = OPTS_TYPE_PT_GENERATE_BE
7705 | OPTS_TYPE_ST_ADD80
7706 | OPTS_TYPE_ST_ADDBITS15;
7707 kern_type = KERN_TYPE_SHA256_PWSLT;
7708 dgst_size = DGST_SIZE_4_8;
7709 parse_func = sha256s_parse_hash;
7710 sort_by_digest = sort_by_digest_4_8;
7711 opti_type = OPTI_TYPE_ZERO_BYTE
7712 | OPTI_TYPE_PRECOMPUTE_INIT
7713 | OPTI_TYPE_PRECOMPUTE_MERKLE
7714 | OPTI_TYPE_EARLY_SKIP
7715 | OPTI_TYPE_NOT_ITERATED
7716 | OPTI_TYPE_APPENDED_SALT
7717 | OPTI_TYPE_RAW_HASH;
7718 dgst_pos0 = 3;
7719 dgst_pos1 = 7;
7720 dgst_pos2 = 2;
7721 dgst_pos3 = 6;
7722 break;
7723
7724 case 1420: hash_type = HASH_TYPE_SHA256;
7725 salt_type = SALT_TYPE_INTERN;
7726 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7727 opts_type = OPTS_TYPE_PT_GENERATE_BE
7728 | OPTS_TYPE_PT_ADD80
7729 | OPTS_TYPE_PT_ADDBITS15;
7730 kern_type = KERN_TYPE_SHA256_SLTPW;
7731 dgst_size = DGST_SIZE_4_8;
7732 parse_func = sha256s_parse_hash;
7733 sort_by_digest = sort_by_digest_4_8;
7734 opti_type = OPTI_TYPE_ZERO_BYTE
7735 | OPTI_TYPE_PRECOMPUTE_INIT
7736 | OPTI_TYPE_PRECOMPUTE_MERKLE
7737 | OPTI_TYPE_EARLY_SKIP
7738 | OPTI_TYPE_NOT_ITERATED
7739 | OPTI_TYPE_PREPENDED_SALT
7740 | OPTI_TYPE_RAW_HASH;
7741 dgst_pos0 = 3;
7742 dgst_pos1 = 7;
7743 dgst_pos2 = 2;
7744 dgst_pos3 = 6;
7745 break;
7746
7747 case 1421: hash_type = HASH_TYPE_SHA256;
7748 salt_type = SALT_TYPE_EMBEDDED;
7749 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7750 opts_type = OPTS_TYPE_PT_GENERATE_BE
7751 | OPTS_TYPE_PT_ADD80
7752 | OPTS_TYPE_PT_ADDBITS15;
7753 kern_type = KERN_TYPE_SHA256_SLTPW;
7754 dgst_size = DGST_SIZE_4_8;
7755 parse_func = hmailserver_parse_hash;
7756 sort_by_digest = sort_by_digest_4_8;
7757 opti_type = OPTI_TYPE_ZERO_BYTE
7758 | OPTI_TYPE_PRECOMPUTE_INIT
7759 | OPTI_TYPE_PRECOMPUTE_MERKLE
7760 | OPTI_TYPE_EARLY_SKIP
7761 | OPTI_TYPE_NOT_ITERATED
7762 | OPTI_TYPE_PREPENDED_SALT
7763 | OPTI_TYPE_RAW_HASH;
7764 dgst_pos0 = 3;
7765 dgst_pos1 = 7;
7766 dgst_pos2 = 2;
7767 dgst_pos3 = 6;
7768 break;
7769
7770 case 1430: hash_type = HASH_TYPE_SHA256;
7771 salt_type = SALT_TYPE_INTERN;
7772 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7773 opts_type = OPTS_TYPE_PT_GENERATE_BE
7774 | OPTS_TYPE_PT_UNICODE
7775 | OPTS_TYPE_ST_ADD80
7776 | OPTS_TYPE_ST_ADDBITS15;
7777 kern_type = KERN_TYPE_SHA256_PWUSLT;
7778 dgst_size = DGST_SIZE_4_8;
7779 parse_func = sha256s_parse_hash;
7780 sort_by_digest = sort_by_digest_4_8;
7781 opti_type = OPTI_TYPE_ZERO_BYTE
7782 | OPTI_TYPE_PRECOMPUTE_INIT
7783 | OPTI_TYPE_PRECOMPUTE_MERKLE
7784 | OPTI_TYPE_EARLY_SKIP
7785 | OPTI_TYPE_NOT_ITERATED
7786 | OPTI_TYPE_APPENDED_SALT
7787 | OPTI_TYPE_RAW_HASH;
7788 dgst_pos0 = 3;
7789 dgst_pos1 = 7;
7790 dgst_pos2 = 2;
7791 dgst_pos3 = 6;
7792 break;
7793
7794 case 1440: hash_type = HASH_TYPE_SHA256;
7795 salt_type = SALT_TYPE_INTERN;
7796 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7797 opts_type = OPTS_TYPE_PT_GENERATE_BE
7798 | OPTS_TYPE_PT_ADD80
7799 | OPTS_TYPE_PT_ADDBITS15
7800 | OPTS_TYPE_PT_UNICODE;
7801 kern_type = KERN_TYPE_SHA256_SLTPWU;
7802 dgst_size = DGST_SIZE_4_8;
7803 parse_func = sha256s_parse_hash;
7804 sort_by_digest = sort_by_digest_4_8;
7805 opti_type = OPTI_TYPE_ZERO_BYTE
7806 | OPTI_TYPE_PRECOMPUTE_INIT
7807 | OPTI_TYPE_PRECOMPUTE_MERKLE
7808 | OPTI_TYPE_EARLY_SKIP
7809 | OPTI_TYPE_NOT_ITERATED
7810 | OPTI_TYPE_PREPENDED_SALT
7811 | OPTI_TYPE_RAW_HASH;
7812 dgst_pos0 = 3;
7813 dgst_pos1 = 7;
7814 dgst_pos2 = 2;
7815 dgst_pos3 = 6;
7816 break;
7817
7818 case 1441: hash_type = HASH_TYPE_SHA256;
7819 salt_type = SALT_TYPE_EMBEDDED;
7820 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7821 opts_type = OPTS_TYPE_PT_GENERATE_BE
7822 | OPTS_TYPE_PT_ADD80
7823 | OPTS_TYPE_PT_ADDBITS15
7824 | OPTS_TYPE_PT_UNICODE
7825 | OPTS_TYPE_ST_BASE64;
7826 kern_type = KERN_TYPE_SHA256_SLTPWU;
7827 dgst_size = DGST_SIZE_4_8;
7828 parse_func = episerver4_parse_hash;
7829 sort_by_digest = sort_by_digest_4_8;
7830 opti_type = OPTI_TYPE_ZERO_BYTE
7831 | OPTI_TYPE_PRECOMPUTE_INIT
7832 | OPTI_TYPE_PRECOMPUTE_MERKLE
7833 | OPTI_TYPE_EARLY_SKIP
7834 | OPTI_TYPE_NOT_ITERATED
7835 | OPTI_TYPE_PREPENDED_SALT
7836 | OPTI_TYPE_RAW_HASH;
7837 dgst_pos0 = 3;
7838 dgst_pos1 = 7;
7839 dgst_pos2 = 2;
7840 dgst_pos3 = 6;
7841 break;
7842
7843 case 1450: hash_type = HASH_TYPE_SHA256;
7844 salt_type = SALT_TYPE_INTERN;
7845 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7846 opts_type = OPTS_TYPE_PT_GENERATE_BE
7847 | OPTS_TYPE_ST_ADD80;
7848 kern_type = KERN_TYPE_HMACSHA256_PW;
7849 dgst_size = DGST_SIZE_4_8;
7850 parse_func = hmacsha256_parse_hash;
7851 sort_by_digest = sort_by_digest_4_8;
7852 opti_type = OPTI_TYPE_ZERO_BYTE
7853 | OPTI_TYPE_NOT_ITERATED;
7854 dgst_pos0 = 3;
7855 dgst_pos1 = 7;
7856 dgst_pos2 = 2;
7857 dgst_pos3 = 6;
7858 break;
7859
7860 case 1460: hash_type = HASH_TYPE_SHA256;
7861 salt_type = SALT_TYPE_INTERN;
7862 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7863 opts_type = OPTS_TYPE_PT_GENERATE_BE
7864 | OPTS_TYPE_PT_ADD80
7865 | OPTS_TYPE_PT_ADDBITS15;
7866 kern_type = KERN_TYPE_HMACSHA256_SLT;
7867 dgst_size = DGST_SIZE_4_8;
7868 parse_func = hmacsha256_parse_hash;
7869 sort_by_digest = sort_by_digest_4_8;
7870 opti_type = OPTI_TYPE_ZERO_BYTE
7871 | OPTI_TYPE_NOT_ITERATED;
7872 dgst_pos0 = 3;
7873 dgst_pos1 = 7;
7874 dgst_pos2 = 2;
7875 dgst_pos3 = 6;
7876 break;
7877
7878 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7879 salt_type = SALT_TYPE_EMBEDDED;
7880 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7881 opts_type = OPTS_TYPE_PT_GENERATE_LE
7882 | OPTS_TYPE_PT_BITSLICE;
7883 kern_type = KERN_TYPE_DESCRYPT;
7884 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7885 parse_func = descrypt_parse_hash;
7886 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7887 opti_type = OPTI_TYPE_ZERO_BYTE
7888 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7889 dgst_pos0 = 0;
7890 dgst_pos1 = 1;
7891 dgst_pos2 = 2;
7892 dgst_pos3 = 3;
7893 break;
7894
7895 case 1600: hash_type = HASH_TYPE_MD5;
7896 salt_type = SALT_TYPE_EMBEDDED;
7897 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7898 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7899 kern_type = KERN_TYPE_APR1CRYPT;
7900 dgst_size = DGST_SIZE_4_4;
7901 parse_func = md5apr1_parse_hash;
7902 sort_by_digest = sort_by_digest_4_4;
7903 opti_type = OPTI_TYPE_ZERO_BYTE;
7904 dgst_pos0 = 0;
7905 dgst_pos1 = 1;
7906 dgst_pos2 = 2;
7907 dgst_pos3 = 3;
7908 break;
7909
7910 case 1700: hash_type = HASH_TYPE_SHA512;
7911 salt_type = SALT_TYPE_NONE;
7912 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7913 opts_type = OPTS_TYPE_PT_GENERATE_BE
7914 | OPTS_TYPE_PT_ADD80
7915 | OPTS_TYPE_PT_ADDBITS15;
7916 kern_type = KERN_TYPE_SHA512;
7917 dgst_size = DGST_SIZE_8_8;
7918 parse_func = sha512_parse_hash;
7919 sort_by_digest = sort_by_digest_8_8;
7920 opti_type = OPTI_TYPE_ZERO_BYTE
7921 | OPTI_TYPE_PRECOMPUTE_INIT
7922 | OPTI_TYPE_PRECOMPUTE_MERKLE
7923 | OPTI_TYPE_EARLY_SKIP
7924 | OPTI_TYPE_NOT_ITERATED
7925 | OPTI_TYPE_NOT_SALTED
7926 | OPTI_TYPE_USES_BITS_64
7927 | OPTI_TYPE_RAW_HASH;
7928 dgst_pos0 = 14;
7929 dgst_pos1 = 15;
7930 dgst_pos2 = 6;
7931 dgst_pos3 = 7;
7932 break;
7933
7934 case 1710: hash_type = HASH_TYPE_SHA512;
7935 salt_type = SALT_TYPE_INTERN;
7936 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7937 opts_type = OPTS_TYPE_PT_GENERATE_BE
7938 | OPTS_TYPE_ST_ADD80
7939 | OPTS_TYPE_ST_ADDBITS15;
7940 kern_type = KERN_TYPE_SHA512_PWSLT;
7941 dgst_size = DGST_SIZE_8_8;
7942 parse_func = sha512s_parse_hash;
7943 sort_by_digest = sort_by_digest_8_8;
7944 opti_type = OPTI_TYPE_ZERO_BYTE
7945 | OPTI_TYPE_PRECOMPUTE_INIT
7946 | OPTI_TYPE_PRECOMPUTE_MERKLE
7947 | OPTI_TYPE_EARLY_SKIP
7948 | OPTI_TYPE_NOT_ITERATED
7949 | OPTI_TYPE_APPENDED_SALT
7950 | OPTI_TYPE_USES_BITS_64
7951 | OPTI_TYPE_RAW_HASH;
7952 dgst_pos0 = 14;
7953 dgst_pos1 = 15;
7954 dgst_pos2 = 6;
7955 dgst_pos3 = 7;
7956 break;
7957
7958 case 1711: hash_type = HASH_TYPE_SHA512;
7959 salt_type = SALT_TYPE_EMBEDDED;
7960 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7961 opts_type = OPTS_TYPE_PT_GENERATE_BE
7962 | OPTS_TYPE_ST_ADD80
7963 | OPTS_TYPE_ST_ADDBITS15;
7964 kern_type = KERN_TYPE_SHA512_PWSLT;
7965 dgst_size = DGST_SIZE_8_8;
7966 parse_func = sha512b64s_parse_hash;
7967 sort_by_digest = sort_by_digest_8_8;
7968 opti_type = OPTI_TYPE_ZERO_BYTE
7969 | OPTI_TYPE_PRECOMPUTE_INIT
7970 | OPTI_TYPE_PRECOMPUTE_MERKLE
7971 | OPTI_TYPE_EARLY_SKIP
7972 | OPTI_TYPE_NOT_ITERATED
7973 | OPTI_TYPE_APPENDED_SALT
7974 | OPTI_TYPE_USES_BITS_64
7975 | OPTI_TYPE_RAW_HASH;
7976 dgst_pos0 = 14;
7977 dgst_pos1 = 15;
7978 dgst_pos2 = 6;
7979 dgst_pos3 = 7;
7980 break;
7981
7982 case 1720: hash_type = HASH_TYPE_SHA512;
7983 salt_type = SALT_TYPE_INTERN;
7984 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7985 opts_type = OPTS_TYPE_PT_GENERATE_BE
7986 | OPTS_TYPE_PT_ADD80
7987 | OPTS_TYPE_PT_ADDBITS15;
7988 kern_type = KERN_TYPE_SHA512_SLTPW;
7989 dgst_size = DGST_SIZE_8_8;
7990 parse_func = sha512s_parse_hash;
7991 sort_by_digest = sort_by_digest_8_8;
7992 opti_type = OPTI_TYPE_ZERO_BYTE
7993 | OPTI_TYPE_PRECOMPUTE_INIT
7994 | OPTI_TYPE_PRECOMPUTE_MERKLE
7995 | OPTI_TYPE_EARLY_SKIP
7996 | OPTI_TYPE_NOT_ITERATED
7997 | OPTI_TYPE_PREPENDED_SALT
7998 | OPTI_TYPE_USES_BITS_64
7999 | OPTI_TYPE_RAW_HASH;
8000 dgst_pos0 = 14;
8001 dgst_pos1 = 15;
8002 dgst_pos2 = 6;
8003 dgst_pos3 = 7;
8004 break;
8005
8006 case 1722: hash_type = HASH_TYPE_SHA512;
8007 salt_type = SALT_TYPE_EMBEDDED;
8008 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8009 opts_type = OPTS_TYPE_PT_GENERATE_BE
8010 | OPTS_TYPE_PT_ADD80
8011 | OPTS_TYPE_PT_ADDBITS15
8012 | OPTS_TYPE_ST_HEX;
8013 kern_type = KERN_TYPE_SHA512_SLTPW;
8014 dgst_size = DGST_SIZE_8_8;
8015 parse_func = osx512_parse_hash;
8016 sort_by_digest = sort_by_digest_8_8;
8017 opti_type = OPTI_TYPE_ZERO_BYTE
8018 | OPTI_TYPE_PRECOMPUTE_INIT
8019 | OPTI_TYPE_PRECOMPUTE_MERKLE
8020 | OPTI_TYPE_EARLY_SKIP
8021 | OPTI_TYPE_NOT_ITERATED
8022 | OPTI_TYPE_PREPENDED_SALT
8023 | OPTI_TYPE_USES_BITS_64
8024 | OPTI_TYPE_RAW_HASH;
8025 dgst_pos0 = 14;
8026 dgst_pos1 = 15;
8027 dgst_pos2 = 6;
8028 dgst_pos3 = 7;
8029 break;
8030
8031 case 1730: hash_type = HASH_TYPE_SHA512;
8032 salt_type = SALT_TYPE_INTERN;
8033 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8034 opts_type = OPTS_TYPE_PT_GENERATE_BE
8035 | OPTS_TYPE_PT_UNICODE
8036 | OPTS_TYPE_ST_ADD80
8037 | OPTS_TYPE_ST_ADDBITS15;
8038 kern_type = KERN_TYPE_SHA512_PWSLTU;
8039 dgst_size = DGST_SIZE_8_8;
8040 parse_func = sha512s_parse_hash;
8041 sort_by_digest = sort_by_digest_8_8;
8042 opti_type = OPTI_TYPE_ZERO_BYTE
8043 | OPTI_TYPE_PRECOMPUTE_INIT
8044 | OPTI_TYPE_PRECOMPUTE_MERKLE
8045 | OPTI_TYPE_EARLY_SKIP
8046 | OPTI_TYPE_NOT_ITERATED
8047 | OPTI_TYPE_APPENDED_SALT
8048 | OPTI_TYPE_USES_BITS_64
8049 | OPTI_TYPE_RAW_HASH;
8050 dgst_pos0 = 14;
8051 dgst_pos1 = 15;
8052 dgst_pos2 = 6;
8053 dgst_pos3 = 7;
8054 break;
8055
8056 case 1731: hash_type = HASH_TYPE_SHA512;
8057 salt_type = SALT_TYPE_EMBEDDED;
8058 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8059 opts_type = OPTS_TYPE_PT_GENERATE_BE
8060 | OPTS_TYPE_PT_UNICODE
8061 | OPTS_TYPE_ST_ADD80
8062 | OPTS_TYPE_ST_ADDBITS15
8063 | OPTS_TYPE_ST_HEX;
8064 kern_type = KERN_TYPE_SHA512_PWSLTU;
8065 dgst_size = DGST_SIZE_8_8;
8066 parse_func = mssql2012_parse_hash;
8067 sort_by_digest = sort_by_digest_8_8;
8068 opti_type = OPTI_TYPE_ZERO_BYTE
8069 | OPTI_TYPE_PRECOMPUTE_INIT
8070 | OPTI_TYPE_PRECOMPUTE_MERKLE
8071 | OPTI_TYPE_EARLY_SKIP
8072 | OPTI_TYPE_NOT_ITERATED
8073 | OPTI_TYPE_APPENDED_SALT
8074 | OPTI_TYPE_USES_BITS_64
8075 | OPTI_TYPE_RAW_HASH;
8076 dgst_pos0 = 14;
8077 dgst_pos1 = 15;
8078 dgst_pos2 = 6;
8079 dgst_pos3 = 7;
8080 break;
8081
8082 case 1740: hash_type = HASH_TYPE_SHA512;
8083 salt_type = SALT_TYPE_INTERN;
8084 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8085 opts_type = OPTS_TYPE_PT_GENERATE_BE
8086 | OPTS_TYPE_PT_ADD80
8087 | OPTS_TYPE_PT_ADDBITS15
8088 | OPTS_TYPE_PT_UNICODE;
8089 kern_type = KERN_TYPE_SHA512_SLTPWU;
8090 dgst_size = DGST_SIZE_8_8;
8091 parse_func = sha512s_parse_hash;
8092 sort_by_digest = sort_by_digest_8_8;
8093 opti_type = OPTI_TYPE_ZERO_BYTE
8094 | OPTI_TYPE_PRECOMPUTE_INIT
8095 | OPTI_TYPE_PRECOMPUTE_MERKLE
8096 | OPTI_TYPE_EARLY_SKIP
8097 | OPTI_TYPE_NOT_ITERATED
8098 | OPTI_TYPE_PREPENDED_SALT
8099 | OPTI_TYPE_USES_BITS_64
8100 | OPTI_TYPE_RAW_HASH;
8101 dgst_pos0 = 14;
8102 dgst_pos1 = 15;
8103 dgst_pos2 = 6;
8104 dgst_pos3 = 7;
8105 break;
8106
8107 case 1750: hash_type = HASH_TYPE_SHA512;
8108 salt_type = SALT_TYPE_INTERN;
8109 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8110 opts_type = OPTS_TYPE_PT_GENERATE_BE
8111 | OPTS_TYPE_ST_ADD80;
8112 kern_type = KERN_TYPE_HMACSHA512_PW;
8113 dgst_size = DGST_SIZE_8_8;
8114 parse_func = hmacsha512_parse_hash;
8115 sort_by_digest = sort_by_digest_8_8;
8116 opti_type = OPTI_TYPE_ZERO_BYTE
8117 | OPTI_TYPE_USES_BITS_64
8118 | OPTI_TYPE_NOT_ITERATED;
8119 dgst_pos0 = 14;
8120 dgst_pos1 = 15;
8121 dgst_pos2 = 6;
8122 dgst_pos3 = 7;
8123 break;
8124
8125 case 1760: hash_type = HASH_TYPE_SHA512;
8126 salt_type = SALT_TYPE_INTERN;
8127 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8128 opts_type = OPTS_TYPE_PT_GENERATE_BE
8129 | OPTS_TYPE_PT_ADD80
8130 | OPTS_TYPE_PT_ADDBITS15;
8131 kern_type = KERN_TYPE_HMACSHA512_SLT;
8132 dgst_size = DGST_SIZE_8_8;
8133 parse_func = hmacsha512_parse_hash;
8134 sort_by_digest = sort_by_digest_8_8;
8135 opti_type = OPTI_TYPE_ZERO_BYTE
8136 | OPTI_TYPE_USES_BITS_64
8137 | OPTI_TYPE_NOT_ITERATED;
8138 dgst_pos0 = 14;
8139 dgst_pos1 = 15;
8140 dgst_pos2 = 6;
8141 dgst_pos3 = 7;
8142 break;
8143
8144 case 1800: hash_type = HASH_TYPE_SHA512;
8145 salt_type = SALT_TYPE_EMBEDDED;
8146 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8147 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8148 kern_type = KERN_TYPE_SHA512CRYPT;
8149 dgst_size = DGST_SIZE_8_8;
8150 parse_func = sha512crypt_parse_hash;
8151 sort_by_digest = sort_by_digest_8_8;
8152 opti_type = OPTI_TYPE_ZERO_BYTE
8153 | OPTI_TYPE_USES_BITS_64;
8154 dgst_pos0 = 0;
8155 dgst_pos1 = 1;
8156 dgst_pos2 = 2;
8157 dgst_pos3 = 3;
8158 break;
8159
8160 case 2100: hash_type = HASH_TYPE_DCC2;
8161 salt_type = SALT_TYPE_EMBEDDED;
8162 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8163 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8164 | OPTS_TYPE_ST_LOWER
8165 | OPTS_TYPE_ST_UNICODE;
8166 kern_type = KERN_TYPE_DCC2;
8167 dgst_size = DGST_SIZE_4_4;
8168 parse_func = dcc2_parse_hash;
8169 sort_by_digest = sort_by_digest_4_4;
8170 opti_type = OPTI_TYPE_ZERO_BYTE;
8171 dgst_pos0 = 0;
8172 dgst_pos1 = 1;
8173 dgst_pos2 = 2;
8174 dgst_pos3 = 3;
8175 break;
8176
8177 case 2400: hash_type = HASH_TYPE_MD5;
8178 salt_type = SALT_TYPE_NONE;
8179 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8180 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8181 kern_type = KERN_TYPE_MD5PIX;
8182 dgst_size = DGST_SIZE_4_4;
8183 parse_func = md5pix_parse_hash;
8184 sort_by_digest = sort_by_digest_4_4;
8185 opti_type = OPTI_TYPE_ZERO_BYTE
8186 | OPTI_TYPE_PRECOMPUTE_INIT
8187 | OPTI_TYPE_PRECOMPUTE_MERKLE
8188 | OPTI_TYPE_EARLY_SKIP
8189 | OPTI_TYPE_NOT_ITERATED
8190 | OPTI_TYPE_NOT_SALTED;
8191 dgst_pos0 = 0;
8192 dgst_pos1 = 3;
8193 dgst_pos2 = 2;
8194 dgst_pos3 = 1;
8195 break;
8196
8197 case 2410: hash_type = HASH_TYPE_MD5;
8198 salt_type = SALT_TYPE_INTERN;
8199 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8200 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8201 kern_type = KERN_TYPE_MD5ASA;
8202 dgst_size = DGST_SIZE_4_4;
8203 parse_func = md5asa_parse_hash;
8204 sort_by_digest = sort_by_digest_4_4;
8205 opti_type = OPTI_TYPE_ZERO_BYTE
8206 | OPTI_TYPE_PRECOMPUTE_INIT
8207 | OPTI_TYPE_PRECOMPUTE_MERKLE
8208 | OPTI_TYPE_EARLY_SKIP
8209 | OPTI_TYPE_NOT_ITERATED;
8210 dgst_pos0 = 0;
8211 dgst_pos1 = 3;
8212 dgst_pos2 = 2;
8213 dgst_pos3 = 1;
8214 break;
8215
8216 case 2500: hash_type = HASH_TYPE_WPA;
8217 salt_type = SALT_TYPE_EMBEDDED;
8218 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8219 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8220 kern_type = KERN_TYPE_WPA;
8221 dgst_size = DGST_SIZE_4_4;
8222 parse_func = wpa_parse_hash;
8223 sort_by_digest = sort_by_digest_4_4;
8224 opti_type = OPTI_TYPE_ZERO_BYTE;
8225 dgst_pos0 = 0;
8226 dgst_pos1 = 1;
8227 dgst_pos2 = 2;
8228 dgst_pos3 = 3;
8229 break;
8230
8231 case 2600: hash_type = HASH_TYPE_MD5;
8232 salt_type = SALT_TYPE_VIRTUAL;
8233 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8234 opts_type = OPTS_TYPE_PT_GENERATE_LE
8235 | OPTS_TYPE_PT_ADD80
8236 | OPTS_TYPE_PT_ADDBITS14
8237 | OPTS_TYPE_ST_ADD80;
8238 kern_type = KERN_TYPE_MD55_PWSLT1;
8239 dgst_size = DGST_SIZE_4_4;
8240 parse_func = md5md5_parse_hash;
8241 sort_by_digest = sort_by_digest_4_4;
8242 opti_type = OPTI_TYPE_ZERO_BYTE
8243 | OPTI_TYPE_PRECOMPUTE_INIT
8244 | OPTI_TYPE_PRECOMPUTE_MERKLE
8245 | OPTI_TYPE_EARLY_SKIP;
8246 dgst_pos0 = 0;
8247 dgst_pos1 = 3;
8248 dgst_pos2 = 2;
8249 dgst_pos3 = 1;
8250 break;
8251
8252 case 2611: hash_type = HASH_TYPE_MD5;
8253 salt_type = SALT_TYPE_INTERN;
8254 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8255 opts_type = OPTS_TYPE_PT_GENERATE_LE
8256 | OPTS_TYPE_PT_ADD80
8257 | OPTS_TYPE_PT_ADDBITS14
8258 | OPTS_TYPE_ST_ADD80;
8259 kern_type = KERN_TYPE_MD55_PWSLT1;
8260 dgst_size = DGST_SIZE_4_4;
8261 parse_func = vb3_parse_hash;
8262 sort_by_digest = sort_by_digest_4_4;
8263 opti_type = OPTI_TYPE_ZERO_BYTE
8264 | OPTI_TYPE_PRECOMPUTE_INIT
8265 | OPTI_TYPE_PRECOMPUTE_MERKLE
8266 | OPTI_TYPE_EARLY_SKIP;
8267 dgst_pos0 = 0;
8268 dgst_pos1 = 3;
8269 dgst_pos2 = 2;
8270 dgst_pos3 = 1;
8271 break;
8272
8273 case 2612: hash_type = HASH_TYPE_MD5;
8274 salt_type = SALT_TYPE_EMBEDDED;
8275 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8276 opts_type = OPTS_TYPE_PT_GENERATE_LE
8277 | OPTS_TYPE_PT_ADD80
8278 | OPTS_TYPE_PT_ADDBITS14
8279 | OPTS_TYPE_ST_ADD80
8280 | OPTS_TYPE_ST_HEX;
8281 kern_type = KERN_TYPE_MD55_PWSLT1;
8282 dgst_size = DGST_SIZE_4_4;
8283 parse_func = phps_parse_hash;
8284 sort_by_digest = sort_by_digest_4_4;
8285 opti_type = OPTI_TYPE_ZERO_BYTE
8286 | OPTI_TYPE_PRECOMPUTE_INIT
8287 | OPTI_TYPE_PRECOMPUTE_MERKLE
8288 | OPTI_TYPE_EARLY_SKIP;
8289 dgst_pos0 = 0;
8290 dgst_pos1 = 3;
8291 dgst_pos2 = 2;
8292 dgst_pos3 = 1;
8293 break;
8294
8295 case 2711: hash_type = HASH_TYPE_MD5;
8296 salt_type = SALT_TYPE_INTERN;
8297 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8298 opts_type = OPTS_TYPE_PT_GENERATE_LE
8299 | OPTS_TYPE_PT_ADD80
8300 | OPTS_TYPE_PT_ADDBITS14
8301 | OPTS_TYPE_ST_ADD80;
8302 kern_type = KERN_TYPE_MD55_PWSLT2;
8303 dgst_size = DGST_SIZE_4_4;
8304 parse_func = vb30_parse_hash;
8305 sort_by_digest = sort_by_digest_4_4;
8306 opti_type = OPTI_TYPE_ZERO_BYTE
8307 | OPTI_TYPE_PRECOMPUTE_INIT
8308 | OPTI_TYPE_EARLY_SKIP;
8309 dgst_pos0 = 0;
8310 dgst_pos1 = 3;
8311 dgst_pos2 = 2;
8312 dgst_pos3 = 1;
8313 break;
8314
8315 case 2811: hash_type = HASH_TYPE_MD5;
8316 salt_type = SALT_TYPE_INTERN;
8317 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8318 opts_type = OPTS_TYPE_PT_GENERATE_LE
8319 | OPTS_TYPE_PT_ADD80
8320 | OPTS_TYPE_PT_ADDBITS14;
8321 kern_type = KERN_TYPE_MD55_SLTPW;
8322 dgst_size = DGST_SIZE_4_4;
8323 parse_func = ipb2_parse_hash;
8324 sort_by_digest = sort_by_digest_4_4;
8325 opti_type = OPTI_TYPE_ZERO_BYTE
8326 | OPTI_TYPE_PRECOMPUTE_INIT
8327 | OPTI_TYPE_EARLY_SKIP;
8328 dgst_pos0 = 0;
8329 dgst_pos1 = 3;
8330 dgst_pos2 = 2;
8331 dgst_pos3 = 1;
8332 break;
8333
8334 case 3000: hash_type = HASH_TYPE_LM;
8335 salt_type = SALT_TYPE_NONE;
8336 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8337 opts_type = OPTS_TYPE_PT_GENERATE_LE
8338 | OPTS_TYPE_PT_UPPER
8339 | OPTS_TYPE_PT_BITSLICE;
8340 kern_type = KERN_TYPE_LM;
8341 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8342 parse_func = lm_parse_hash;
8343 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8344 opti_type = OPTI_TYPE_ZERO_BYTE
8345 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8346 dgst_pos0 = 0;
8347 dgst_pos1 = 1;
8348 dgst_pos2 = 2;
8349 dgst_pos3 = 3;
8350 break;
8351
8352 case 3100: hash_type = HASH_TYPE_ORACLEH;
8353 salt_type = SALT_TYPE_INTERN;
8354 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8355 opts_type = OPTS_TYPE_PT_GENERATE_LE
8356 | OPTS_TYPE_PT_UPPER
8357 | OPTS_TYPE_ST_UPPER;
8358 kern_type = KERN_TYPE_ORACLEH;
8359 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8360 parse_func = oracleh_parse_hash;
8361 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8362 opti_type = OPTI_TYPE_ZERO_BYTE;
8363 dgst_pos0 = 0;
8364 dgst_pos1 = 1;
8365 dgst_pos2 = 2;
8366 dgst_pos3 = 3;
8367 break;
8368
8369 case 3200: hash_type = HASH_TYPE_BCRYPT;
8370 salt_type = SALT_TYPE_EMBEDDED;
8371 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8372 opts_type = OPTS_TYPE_PT_GENERATE_LE
8373 | OPTS_TYPE_ST_GENERATE_LE;
8374 kern_type = KERN_TYPE_BCRYPT;
8375 dgst_size = DGST_SIZE_4_6;
8376 parse_func = bcrypt_parse_hash;
8377 sort_by_digest = sort_by_digest_4_6;
8378 opti_type = OPTI_TYPE_ZERO_BYTE;
8379 dgst_pos0 = 0;
8380 dgst_pos1 = 1;
8381 dgst_pos2 = 2;
8382 dgst_pos3 = 3;
8383 break;
8384
8385 case 3710: hash_type = HASH_TYPE_MD5;
8386 salt_type = SALT_TYPE_INTERN;
8387 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8388 opts_type = OPTS_TYPE_PT_GENERATE_LE
8389 | OPTS_TYPE_PT_ADD80
8390 | OPTS_TYPE_PT_ADDBITS14;
8391 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8392 dgst_size = DGST_SIZE_4_4;
8393 parse_func = md5s_parse_hash;
8394 sort_by_digest = sort_by_digest_4_4;
8395 opti_type = OPTI_TYPE_ZERO_BYTE
8396 | OPTI_TYPE_PRECOMPUTE_INIT
8397 | OPTI_TYPE_PRECOMPUTE_MERKLE
8398 | OPTI_TYPE_EARLY_SKIP;
8399 dgst_pos0 = 0;
8400 dgst_pos1 = 3;
8401 dgst_pos2 = 2;
8402 dgst_pos3 = 1;
8403 break;
8404
8405 case 3711: hash_type = HASH_TYPE_MD5;
8406 salt_type = SALT_TYPE_EMBEDDED;
8407 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8408 opts_type = OPTS_TYPE_PT_GENERATE_LE
8409 | OPTS_TYPE_PT_ADD80
8410 | OPTS_TYPE_PT_ADDBITS14;
8411 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8412 dgst_size = DGST_SIZE_4_4;
8413 parse_func = mediawiki_b_parse_hash;
8414 sort_by_digest = sort_by_digest_4_4;
8415 opti_type = OPTI_TYPE_ZERO_BYTE
8416 | OPTI_TYPE_PRECOMPUTE_INIT
8417 | OPTI_TYPE_PRECOMPUTE_MERKLE
8418 | OPTI_TYPE_EARLY_SKIP;
8419 dgst_pos0 = 0;
8420 dgst_pos1 = 3;
8421 dgst_pos2 = 2;
8422 dgst_pos3 = 1;
8423 break;
8424
8425 case 3800: hash_type = HASH_TYPE_MD5;
8426 salt_type = SALT_TYPE_INTERN;
8427 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8428 opts_type = OPTS_TYPE_PT_GENERATE_LE
8429 | OPTS_TYPE_ST_ADDBITS14;
8430 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8431 dgst_size = DGST_SIZE_4_4;
8432 parse_func = md5s_parse_hash;
8433 sort_by_digest = sort_by_digest_4_4;
8434 opti_type = OPTI_TYPE_ZERO_BYTE
8435 | OPTI_TYPE_PRECOMPUTE_INIT
8436 | OPTI_TYPE_PRECOMPUTE_MERKLE
8437 | OPTI_TYPE_EARLY_SKIP
8438 | OPTI_TYPE_NOT_ITERATED
8439 | OPTI_TYPE_RAW_HASH;
8440 dgst_pos0 = 0;
8441 dgst_pos1 = 3;
8442 dgst_pos2 = 2;
8443 dgst_pos3 = 1;
8444 break;
8445
8446 case 4300: hash_type = HASH_TYPE_MD5;
8447 salt_type = SALT_TYPE_VIRTUAL;
8448 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8449 opts_type = OPTS_TYPE_PT_GENERATE_LE
8450 | OPTS_TYPE_PT_ADD80
8451 | OPTS_TYPE_PT_ADDBITS14
8452 | OPTS_TYPE_ST_ADD80;
8453 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8454 dgst_size = DGST_SIZE_4_4;
8455 parse_func = md5md5_parse_hash;
8456 sort_by_digest = sort_by_digest_4_4;
8457 opti_type = OPTI_TYPE_ZERO_BYTE
8458 | OPTI_TYPE_PRECOMPUTE_INIT
8459 | OPTI_TYPE_PRECOMPUTE_MERKLE
8460 | OPTI_TYPE_EARLY_SKIP;
8461 dgst_pos0 = 0;
8462 dgst_pos1 = 3;
8463 dgst_pos2 = 2;
8464 dgst_pos3 = 1;
8465 break;
8466
8467
8468 case 4400: hash_type = HASH_TYPE_MD5;
8469 salt_type = SALT_TYPE_NONE;
8470 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8471 opts_type = OPTS_TYPE_PT_GENERATE_BE
8472 | OPTS_TYPE_PT_ADD80
8473 | OPTS_TYPE_PT_ADDBITS15;
8474 kern_type = KERN_TYPE_MD5_SHA1;
8475 dgst_size = DGST_SIZE_4_4;
8476 parse_func = md5_parse_hash;
8477 sort_by_digest = sort_by_digest_4_4;
8478 opti_type = OPTI_TYPE_ZERO_BYTE
8479 | OPTI_TYPE_PRECOMPUTE_INIT
8480 | OPTI_TYPE_PRECOMPUTE_MERKLE
8481 | OPTI_TYPE_EARLY_SKIP
8482 | OPTI_TYPE_NOT_ITERATED
8483 | OPTI_TYPE_NOT_SALTED
8484 | OPTI_TYPE_RAW_HASH;
8485 dgst_pos0 = 0;
8486 dgst_pos1 = 3;
8487 dgst_pos2 = 2;
8488 dgst_pos3 = 1;
8489 break;
8490
8491 case 4500: hash_type = HASH_TYPE_SHA1;
8492 salt_type = SALT_TYPE_NONE;
8493 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8494 opts_type = OPTS_TYPE_PT_GENERATE_BE
8495 | OPTS_TYPE_PT_ADD80
8496 | OPTS_TYPE_PT_ADDBITS15;
8497 kern_type = KERN_TYPE_SHA11;
8498 dgst_size = DGST_SIZE_4_5;
8499 parse_func = sha1_parse_hash;
8500 sort_by_digest = sort_by_digest_4_5;
8501 opti_type = OPTI_TYPE_ZERO_BYTE
8502 | OPTI_TYPE_PRECOMPUTE_INIT
8503 | OPTI_TYPE_PRECOMPUTE_MERKLE
8504 | OPTI_TYPE_EARLY_SKIP
8505 | OPTI_TYPE_NOT_SALTED;
8506 dgst_pos0 = 3;
8507 dgst_pos1 = 4;
8508 dgst_pos2 = 2;
8509 dgst_pos3 = 1;
8510 break;
8511
8512 case 4700: hash_type = HASH_TYPE_SHA1;
8513 salt_type = SALT_TYPE_NONE;
8514 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8515 opts_type = OPTS_TYPE_PT_GENERATE_LE
8516 | OPTS_TYPE_PT_ADD80
8517 | OPTS_TYPE_PT_ADDBITS14;
8518 kern_type = KERN_TYPE_SHA1_MD5;
8519 dgst_size = DGST_SIZE_4_5;
8520 parse_func = sha1_parse_hash;
8521 sort_by_digest = sort_by_digest_4_5;
8522 opti_type = OPTI_TYPE_ZERO_BYTE
8523 | OPTI_TYPE_PRECOMPUTE_INIT
8524 | OPTI_TYPE_PRECOMPUTE_MERKLE
8525 | OPTI_TYPE_EARLY_SKIP
8526 | OPTI_TYPE_NOT_ITERATED
8527 | OPTI_TYPE_NOT_SALTED
8528 | OPTI_TYPE_RAW_HASH;
8529 dgst_pos0 = 3;
8530 dgst_pos1 = 4;
8531 dgst_pos2 = 2;
8532 dgst_pos3 = 1;
8533 break;
8534
8535 case 4800: hash_type = HASH_TYPE_MD5;
8536 salt_type = SALT_TYPE_EMBEDDED;
8537 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8538 opts_type = OPTS_TYPE_PT_GENERATE_LE
8539 | OPTS_TYPE_PT_ADDBITS14;
8540 kern_type = KERN_TYPE_MD5_CHAP;
8541 dgst_size = DGST_SIZE_4_4;
8542 parse_func = chap_parse_hash;
8543 sort_by_digest = sort_by_digest_4_4;
8544 opti_type = OPTI_TYPE_ZERO_BYTE
8545 | OPTI_TYPE_PRECOMPUTE_INIT
8546 | OPTI_TYPE_PRECOMPUTE_MERKLE
8547 | OPTI_TYPE_MEET_IN_MIDDLE
8548 | OPTI_TYPE_EARLY_SKIP
8549 | OPTI_TYPE_NOT_ITERATED
8550 | OPTI_TYPE_RAW_HASH;
8551 dgst_pos0 = 0;
8552 dgst_pos1 = 3;
8553 dgst_pos2 = 2;
8554 dgst_pos3 = 1;
8555 break;
8556
8557 case 4900: hash_type = HASH_TYPE_SHA1;
8558 salt_type = SALT_TYPE_INTERN;
8559 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8560 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8561 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8562 dgst_size = DGST_SIZE_4_5;
8563 parse_func = sha1s_parse_hash;
8564 sort_by_digest = sort_by_digest_4_5;
8565 opti_type = OPTI_TYPE_ZERO_BYTE
8566 | OPTI_TYPE_PRECOMPUTE_INIT
8567 | OPTI_TYPE_PRECOMPUTE_MERKLE
8568 | OPTI_TYPE_EARLY_SKIP;
8569 dgst_pos0 = 3;
8570 dgst_pos1 = 4;
8571 dgst_pos2 = 2;
8572 dgst_pos3 = 1;
8573 break;
8574
8575 case 5000: hash_type = HASH_TYPE_KECCAK;
8576 salt_type = SALT_TYPE_EMBEDDED;
8577 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8578 opts_type = OPTS_TYPE_PT_GENERATE_LE
8579 | OPTS_TYPE_PT_ADD01;
8580 kern_type = KERN_TYPE_KECCAK;
8581 dgst_size = DGST_SIZE_8_25;
8582 parse_func = keccak_parse_hash;
8583 sort_by_digest = sort_by_digest_8_25;
8584 opti_type = OPTI_TYPE_ZERO_BYTE
8585 | OPTI_TYPE_USES_BITS_64
8586 | OPTI_TYPE_RAW_HASH;
8587 dgst_pos0 = 2;
8588 dgst_pos1 = 3;
8589 dgst_pos2 = 4;
8590 dgst_pos3 = 5;
8591 break;
8592
8593 case 5100: hash_type = HASH_TYPE_MD5H;
8594 salt_type = SALT_TYPE_NONE;
8595 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8596 opts_type = OPTS_TYPE_PT_GENERATE_LE
8597 | OPTS_TYPE_PT_ADD80
8598 | OPTS_TYPE_PT_ADDBITS14;
8599 kern_type = KERN_TYPE_MD5H;
8600 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8601 parse_func = md5half_parse_hash;
8602 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8603 opti_type = OPTI_TYPE_ZERO_BYTE
8604 | OPTI_TYPE_RAW_HASH;
8605 dgst_pos0 = 0;
8606 dgst_pos1 = 1;
8607 dgst_pos2 = 2;
8608 dgst_pos3 = 3;
8609 break;
8610
8611 case 5200: hash_type = HASH_TYPE_SHA256;
8612 salt_type = SALT_TYPE_EMBEDDED;
8613 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8614 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8615 kern_type = KERN_TYPE_PSAFE3;
8616 dgst_size = DGST_SIZE_4_8;
8617 parse_func = psafe3_parse_hash;
8618 sort_by_digest = sort_by_digest_4_8;
8619 opti_type = OPTI_TYPE_ZERO_BYTE;
8620 dgst_pos0 = 0;
8621 dgst_pos1 = 1;
8622 dgst_pos2 = 2;
8623 dgst_pos3 = 3;
8624 break;
8625
8626 case 5300: hash_type = HASH_TYPE_MD5;
8627 salt_type = SALT_TYPE_EMBEDDED;
8628 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8629 opts_type = OPTS_TYPE_PT_GENERATE_LE
8630 | OPTS_TYPE_ST_ADD80;
8631 kern_type = KERN_TYPE_IKEPSK_MD5;
8632 dgst_size = DGST_SIZE_4_4;
8633 parse_func = ikepsk_md5_parse_hash;
8634 sort_by_digest = sort_by_digest_4_4;
8635 opti_type = OPTI_TYPE_ZERO_BYTE;
8636 dgst_pos0 = 0;
8637 dgst_pos1 = 3;
8638 dgst_pos2 = 2;
8639 dgst_pos3 = 1;
8640 break;
8641
8642 case 5400: hash_type = HASH_TYPE_SHA1;
8643 salt_type = SALT_TYPE_EMBEDDED;
8644 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8645 opts_type = OPTS_TYPE_PT_GENERATE_BE
8646 | OPTS_TYPE_ST_ADD80;
8647 kern_type = KERN_TYPE_IKEPSK_SHA1;
8648 dgst_size = DGST_SIZE_4_5;
8649 parse_func = ikepsk_sha1_parse_hash;
8650 sort_by_digest = sort_by_digest_4_5;
8651 opti_type = OPTI_TYPE_ZERO_BYTE;
8652 dgst_pos0 = 3;
8653 dgst_pos1 = 4;
8654 dgst_pos2 = 2;
8655 dgst_pos3 = 1;
8656 break;
8657
8658 case 5500: hash_type = HASH_TYPE_NETNTLM;
8659 salt_type = SALT_TYPE_EMBEDDED;
8660 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8661 opts_type = OPTS_TYPE_PT_GENERATE_LE
8662 | OPTS_TYPE_PT_ADD80
8663 | OPTS_TYPE_PT_ADDBITS14
8664 | OPTS_TYPE_PT_UNICODE
8665 | OPTS_TYPE_ST_HEX;
8666 kern_type = KERN_TYPE_NETNTLMv1;
8667 dgst_size = DGST_SIZE_4_4;
8668 parse_func = netntlmv1_parse_hash;
8669 sort_by_digest = sort_by_digest_4_4;
8670 opti_type = OPTI_TYPE_ZERO_BYTE
8671 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8672 dgst_pos0 = 0;
8673 dgst_pos1 = 1;
8674 dgst_pos2 = 2;
8675 dgst_pos3 = 3;
8676 break;
8677
8678 case 5600: hash_type = HASH_TYPE_MD5;
8679 salt_type = SALT_TYPE_EMBEDDED;
8680 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8681 opts_type = OPTS_TYPE_PT_GENERATE_LE
8682 | OPTS_TYPE_PT_ADD80
8683 | OPTS_TYPE_PT_ADDBITS14
8684 | OPTS_TYPE_PT_UNICODE;
8685 kern_type = KERN_TYPE_NETNTLMv2;
8686 dgst_size = DGST_SIZE_4_4;
8687 parse_func = netntlmv2_parse_hash;
8688 sort_by_digest = sort_by_digest_4_4;
8689 opti_type = OPTI_TYPE_ZERO_BYTE;
8690 dgst_pos0 = 0;
8691 dgst_pos1 = 3;
8692 dgst_pos2 = 2;
8693 dgst_pos3 = 1;
8694 break;
8695
8696 case 5700: hash_type = HASH_TYPE_SHA256;
8697 salt_type = SALT_TYPE_NONE;
8698 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8699 opts_type = OPTS_TYPE_PT_GENERATE_BE
8700 | OPTS_TYPE_PT_ADD80
8701 | OPTS_TYPE_PT_ADDBITS15;
8702 kern_type = KERN_TYPE_SHA256;
8703 dgst_size = DGST_SIZE_4_8;
8704 parse_func = cisco4_parse_hash;
8705 sort_by_digest = sort_by_digest_4_8;
8706 opti_type = OPTI_TYPE_ZERO_BYTE
8707 | OPTI_TYPE_PRECOMPUTE_INIT
8708 | OPTI_TYPE_PRECOMPUTE_MERKLE
8709 | OPTI_TYPE_EARLY_SKIP
8710 | OPTI_TYPE_NOT_ITERATED
8711 | OPTI_TYPE_NOT_SALTED
8712 | OPTI_TYPE_RAW_HASH;
8713 dgst_pos0 = 3;
8714 dgst_pos1 = 7;
8715 dgst_pos2 = 2;
8716 dgst_pos3 = 6;
8717 break;
8718
8719 case 5800: hash_type = HASH_TYPE_SHA1;
8720 salt_type = SALT_TYPE_INTERN;
8721 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8722 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8723 | OPTS_TYPE_ST_ADD80;
8724 kern_type = KERN_TYPE_ANDROIDPIN;
8725 dgst_size = DGST_SIZE_4_5;
8726 parse_func = androidpin_parse_hash;
8727 sort_by_digest = sort_by_digest_4_5;
8728 opti_type = OPTI_TYPE_ZERO_BYTE;
8729 dgst_pos0 = 0;
8730 dgst_pos1 = 1;
8731 dgst_pos2 = 2;
8732 dgst_pos3 = 3;
8733 break;
8734
8735 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8736 salt_type = SALT_TYPE_NONE;
8737 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8738 opts_type = OPTS_TYPE_PT_GENERATE_LE
8739 | OPTS_TYPE_PT_ADD80;
8740 kern_type = KERN_TYPE_RIPEMD160;
8741 dgst_size = DGST_SIZE_4_5;
8742 parse_func = ripemd160_parse_hash;
8743 sort_by_digest = sort_by_digest_4_5;
8744 opti_type = OPTI_TYPE_ZERO_BYTE;
8745 dgst_pos0 = 0;
8746 dgst_pos1 = 1;
8747 dgst_pos2 = 2;
8748 dgst_pos3 = 3;
8749 break;
8750
8751 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8752 salt_type = SALT_TYPE_NONE;
8753 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8754 opts_type = OPTS_TYPE_PT_GENERATE_BE
8755 | OPTS_TYPE_PT_ADD80;
8756 kern_type = KERN_TYPE_WHIRLPOOL;
8757 dgst_size = DGST_SIZE_4_16;
8758 parse_func = whirlpool_parse_hash;
8759 sort_by_digest = sort_by_digest_4_16;
8760 opti_type = OPTI_TYPE_ZERO_BYTE;
8761 dgst_pos0 = 0;
8762 dgst_pos1 = 1;
8763 dgst_pos2 = 2;
8764 dgst_pos3 = 3;
8765 break;
8766
8767 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8768 salt_type = SALT_TYPE_EMBEDDED;
8769 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8770 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8771 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8772 dgst_size = DGST_SIZE_4_5;
8773 parse_func = truecrypt_parse_hash_2k;
8774 sort_by_digest = sort_by_digest_4_5;
8775 opti_type = OPTI_TYPE_ZERO_BYTE;
8776 dgst_pos0 = 0;
8777 dgst_pos1 = 1;
8778 dgst_pos2 = 2;
8779 dgst_pos3 = 3;
8780 break;
8781
8782 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8783 salt_type = SALT_TYPE_EMBEDDED;
8784 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8785 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8786 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8787 dgst_size = DGST_SIZE_4_5;
8788 parse_func = truecrypt_parse_hash_2k;
8789 sort_by_digest = sort_by_digest_4_5;
8790 opti_type = OPTI_TYPE_ZERO_BYTE;
8791 dgst_pos0 = 0;
8792 dgst_pos1 = 1;
8793 dgst_pos2 = 2;
8794 dgst_pos3 = 3;
8795 break;
8796
8797 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8798 salt_type = SALT_TYPE_EMBEDDED;
8799 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8800 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8801 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8802 dgst_size = DGST_SIZE_4_5;
8803 parse_func = truecrypt_parse_hash_2k;
8804 sort_by_digest = sort_by_digest_4_5;
8805 opti_type = OPTI_TYPE_ZERO_BYTE;
8806 dgst_pos0 = 0;
8807 dgst_pos1 = 1;
8808 dgst_pos2 = 2;
8809 dgst_pos3 = 3;
8810 break;
8811
8812 case 6221: hash_type = HASH_TYPE_SHA512;
8813 salt_type = SALT_TYPE_EMBEDDED;
8814 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8815 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8816 kern_type = KERN_TYPE_TCSHA512_XTS512;
8817 dgst_size = DGST_SIZE_8_8;
8818 parse_func = truecrypt_parse_hash_1k;
8819 sort_by_digest = sort_by_digest_8_8;
8820 opti_type = OPTI_TYPE_ZERO_BYTE
8821 | OPTI_TYPE_USES_BITS_64;
8822 dgst_pos0 = 0;
8823 dgst_pos1 = 1;
8824 dgst_pos2 = 2;
8825 dgst_pos3 = 3;
8826 break;
8827
8828 case 6222: hash_type = HASH_TYPE_SHA512;
8829 salt_type = SALT_TYPE_EMBEDDED;
8830 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8831 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8832 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8833 dgst_size = DGST_SIZE_8_8;
8834 parse_func = truecrypt_parse_hash_1k;
8835 sort_by_digest = sort_by_digest_8_8;
8836 opti_type = OPTI_TYPE_ZERO_BYTE
8837 | OPTI_TYPE_USES_BITS_64;
8838 dgst_pos0 = 0;
8839 dgst_pos1 = 1;
8840 dgst_pos2 = 2;
8841 dgst_pos3 = 3;
8842 break;
8843
8844 case 6223: hash_type = HASH_TYPE_SHA512;
8845 salt_type = SALT_TYPE_EMBEDDED;
8846 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8847 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8848 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8849 dgst_size = DGST_SIZE_8_8;
8850 parse_func = truecrypt_parse_hash_1k;
8851 sort_by_digest = sort_by_digest_8_8;
8852 opti_type = OPTI_TYPE_ZERO_BYTE
8853 | OPTI_TYPE_USES_BITS_64;
8854 dgst_pos0 = 0;
8855 dgst_pos1 = 1;
8856 dgst_pos2 = 2;
8857 dgst_pos3 = 3;
8858 break;
8859
8860 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8861 salt_type = SALT_TYPE_EMBEDDED;
8862 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8863 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8864 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8865 dgst_size = DGST_SIZE_4_8;
8866 parse_func = truecrypt_parse_hash_1k;
8867 sort_by_digest = sort_by_digest_4_8;
8868 opti_type = OPTI_TYPE_ZERO_BYTE;
8869 dgst_pos0 = 0;
8870 dgst_pos1 = 1;
8871 dgst_pos2 = 2;
8872 dgst_pos3 = 3;
8873 break;
8874
8875 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8876 salt_type = SALT_TYPE_EMBEDDED;
8877 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8878 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8879 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8880 dgst_size = DGST_SIZE_4_8;
8881 parse_func = truecrypt_parse_hash_1k;
8882 sort_by_digest = sort_by_digest_4_8;
8883 opti_type = OPTI_TYPE_ZERO_BYTE;
8884 dgst_pos0 = 0;
8885 dgst_pos1 = 1;
8886 dgst_pos2 = 2;
8887 dgst_pos3 = 3;
8888 break;
8889
8890 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8891 salt_type = SALT_TYPE_EMBEDDED;
8892 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8893 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8894 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8895 dgst_size = DGST_SIZE_4_8;
8896 parse_func = truecrypt_parse_hash_1k;
8897 sort_by_digest = sort_by_digest_4_8;
8898 opti_type = OPTI_TYPE_ZERO_BYTE;
8899 dgst_pos0 = 0;
8900 dgst_pos1 = 1;
8901 dgst_pos2 = 2;
8902 dgst_pos3 = 3;
8903 break;
8904
8905 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8906 salt_type = SALT_TYPE_EMBEDDED;
8907 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8908 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8909 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8910 dgst_size = DGST_SIZE_4_5;
8911 parse_func = truecrypt_parse_hash_1k;
8912 sort_by_digest = sort_by_digest_4_5;
8913 opti_type = OPTI_TYPE_ZERO_BYTE;
8914 dgst_pos0 = 0;
8915 dgst_pos1 = 1;
8916 dgst_pos2 = 2;
8917 dgst_pos3 = 3;
8918 break;
8919
8920 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8921 salt_type = SALT_TYPE_EMBEDDED;
8922 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8923 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8924 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8925 dgst_size = DGST_SIZE_4_5;
8926 parse_func = truecrypt_parse_hash_1k;
8927 sort_by_digest = sort_by_digest_4_5;
8928 opti_type = OPTI_TYPE_ZERO_BYTE;
8929 dgst_pos0 = 0;
8930 dgst_pos1 = 1;
8931 dgst_pos2 = 2;
8932 dgst_pos3 = 3;
8933 break;
8934
8935 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8936 salt_type = SALT_TYPE_EMBEDDED;
8937 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8938 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8939 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8940 dgst_size = DGST_SIZE_4_5;
8941 parse_func = truecrypt_parse_hash_1k;
8942 sort_by_digest = sort_by_digest_4_5;
8943 opti_type = OPTI_TYPE_ZERO_BYTE;
8944 dgst_pos0 = 0;
8945 dgst_pos1 = 1;
8946 dgst_pos2 = 2;
8947 dgst_pos3 = 3;
8948 break;
8949
8950 case 6300: hash_type = HASH_TYPE_MD5;
8951 salt_type = SALT_TYPE_EMBEDDED;
8952 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8953 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8954 kern_type = KERN_TYPE_MD5AIX;
8955 dgst_size = DGST_SIZE_4_4;
8956 parse_func = md5aix_parse_hash;
8957 sort_by_digest = sort_by_digest_4_4;
8958 opti_type = OPTI_TYPE_ZERO_BYTE;
8959 dgst_pos0 = 0;
8960 dgst_pos1 = 1;
8961 dgst_pos2 = 2;
8962 dgst_pos3 = 3;
8963 break;
8964
8965 case 6400: hash_type = HASH_TYPE_SHA256;
8966 salt_type = SALT_TYPE_EMBEDDED;
8967 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8968 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8969 kern_type = KERN_TYPE_SHA256AIX;
8970 dgst_size = DGST_SIZE_4_8;
8971 parse_func = sha256aix_parse_hash;
8972 sort_by_digest = sort_by_digest_4_8;
8973 opti_type = OPTI_TYPE_ZERO_BYTE;
8974 dgst_pos0 = 0;
8975 dgst_pos1 = 1;
8976 dgst_pos2 = 2;
8977 dgst_pos3 = 3;
8978 break;
8979
8980 case 6500: hash_type = HASH_TYPE_SHA512;
8981 salt_type = SALT_TYPE_EMBEDDED;
8982 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8983 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8984 kern_type = KERN_TYPE_SHA512AIX;
8985 dgst_size = DGST_SIZE_8_8;
8986 parse_func = sha512aix_parse_hash;
8987 sort_by_digest = sort_by_digest_8_8;
8988 opti_type = OPTI_TYPE_ZERO_BYTE
8989 | OPTI_TYPE_USES_BITS_64;
8990 dgst_pos0 = 0;
8991 dgst_pos1 = 1;
8992 dgst_pos2 = 2;
8993 dgst_pos3 = 3;
8994 break;
8995
8996 case 6600: hash_type = HASH_TYPE_AES;
8997 salt_type = SALT_TYPE_EMBEDDED;
8998 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8999 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9000 kern_type = KERN_TYPE_AGILEKEY;
9001 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9002 parse_func = agilekey_parse_hash;
9003 sort_by_digest = sort_by_digest_4_5;
9004 opti_type = OPTI_TYPE_ZERO_BYTE;
9005 dgst_pos0 = 0;
9006 dgst_pos1 = 1;
9007 dgst_pos2 = 2;
9008 dgst_pos3 = 3;
9009 break;
9010
9011 case 6700: hash_type = HASH_TYPE_SHA1;
9012 salt_type = SALT_TYPE_EMBEDDED;
9013 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9014 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9015 kern_type = KERN_TYPE_SHA1AIX;
9016 dgst_size = DGST_SIZE_4_5;
9017 parse_func = sha1aix_parse_hash;
9018 sort_by_digest = sort_by_digest_4_5;
9019 opti_type = OPTI_TYPE_ZERO_BYTE;
9020 dgst_pos0 = 0;
9021 dgst_pos1 = 1;
9022 dgst_pos2 = 2;
9023 dgst_pos3 = 3;
9024 break;
9025
9026 case 6800: hash_type = HASH_TYPE_AES;
9027 salt_type = SALT_TYPE_EMBEDDED;
9028 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9029 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9030 kern_type = KERN_TYPE_LASTPASS;
9031 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9032 parse_func = lastpass_parse_hash;
9033 sort_by_digest = sort_by_digest_4_8;
9034 opti_type = OPTI_TYPE_ZERO_BYTE;
9035 dgst_pos0 = 0;
9036 dgst_pos1 = 1;
9037 dgst_pos2 = 2;
9038 dgst_pos3 = 3;
9039 break;
9040
9041 case 6900: hash_type = HASH_TYPE_GOST;
9042 salt_type = SALT_TYPE_NONE;
9043 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9044 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9045 kern_type = KERN_TYPE_GOST;
9046 dgst_size = DGST_SIZE_4_8;
9047 parse_func = gost_parse_hash;
9048 sort_by_digest = sort_by_digest_4_8;
9049 opti_type = OPTI_TYPE_ZERO_BYTE;
9050 dgst_pos0 = 0;
9051 dgst_pos1 = 1;
9052 dgst_pos2 = 2;
9053 dgst_pos3 = 3;
9054 break;
9055
9056 case 7100: hash_type = HASH_TYPE_SHA512;
9057 salt_type = SALT_TYPE_EMBEDDED;
9058 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9059 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9060 kern_type = KERN_TYPE_PBKDF2_SHA512;
9061 dgst_size = DGST_SIZE_8_16;
9062 parse_func = sha512osx_parse_hash;
9063 sort_by_digest = sort_by_digest_8_16;
9064 opti_type = OPTI_TYPE_ZERO_BYTE
9065 | OPTI_TYPE_USES_BITS_64;
9066 dgst_pos0 = 0;
9067 dgst_pos1 = 1;
9068 dgst_pos2 = 2;
9069 dgst_pos3 = 3;
9070 break;
9071
9072 case 7200: hash_type = HASH_TYPE_SHA512;
9073 salt_type = SALT_TYPE_EMBEDDED;
9074 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9075 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9076 kern_type = KERN_TYPE_PBKDF2_SHA512;
9077 dgst_size = DGST_SIZE_8_16;
9078 parse_func = sha512grub_parse_hash;
9079 sort_by_digest = sort_by_digest_8_16;
9080 opti_type = OPTI_TYPE_ZERO_BYTE
9081 | OPTI_TYPE_USES_BITS_64;
9082 dgst_pos0 = 0;
9083 dgst_pos1 = 1;
9084 dgst_pos2 = 2;
9085 dgst_pos3 = 3;
9086 break;
9087
9088 case 7300: hash_type = HASH_TYPE_SHA1;
9089 salt_type = SALT_TYPE_EMBEDDED;
9090 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9091 opts_type = OPTS_TYPE_PT_GENERATE_BE
9092 | OPTS_TYPE_ST_ADD80
9093 | OPTS_TYPE_ST_ADDBITS15;
9094 kern_type = KERN_TYPE_RAKP;
9095 dgst_size = DGST_SIZE_4_5;
9096 parse_func = rakp_parse_hash;
9097 sort_by_digest = sort_by_digest_4_5;
9098 opti_type = OPTI_TYPE_ZERO_BYTE
9099 | OPTI_TYPE_NOT_ITERATED;
9100 dgst_pos0 = 3;
9101 dgst_pos1 = 4;
9102 dgst_pos2 = 2;
9103 dgst_pos3 = 1;
9104 break;
9105
9106 case 7400: hash_type = HASH_TYPE_SHA256;
9107 salt_type = SALT_TYPE_EMBEDDED;
9108 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9109 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9110 kern_type = KERN_TYPE_SHA256CRYPT;
9111 dgst_size = DGST_SIZE_4_8;
9112 parse_func = sha256crypt_parse_hash;
9113 sort_by_digest = sort_by_digest_4_8;
9114 opti_type = OPTI_TYPE_ZERO_BYTE;
9115 dgst_pos0 = 0;
9116 dgst_pos1 = 1;
9117 dgst_pos2 = 2;
9118 dgst_pos3 = 3;
9119 break;
9120
9121 case 7500: hash_type = HASH_TYPE_KRB5PA;
9122 salt_type = SALT_TYPE_EMBEDDED;
9123 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9124 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9125 kern_type = KERN_TYPE_KRB5PA;
9126 dgst_size = DGST_SIZE_4_4;
9127 parse_func = krb5pa_parse_hash;
9128 sort_by_digest = sort_by_digest_4_4;
9129 opti_type = OPTI_TYPE_ZERO_BYTE
9130 | OPTI_TYPE_NOT_ITERATED;
9131 dgst_pos0 = 0;
9132 dgst_pos1 = 1;
9133 dgst_pos2 = 2;
9134 dgst_pos3 = 3;
9135 break;
9136
9137 case 7600: hash_type = HASH_TYPE_SHA1;
9138 salt_type = SALT_TYPE_INTERN;
9139 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9140 opts_type = OPTS_TYPE_PT_GENERATE_BE
9141 | OPTS_TYPE_PT_ADD80
9142 | OPTS_TYPE_PT_ADDBITS15;
9143 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9144 dgst_size = DGST_SIZE_4_5;
9145 parse_func = redmine_parse_hash;
9146 sort_by_digest = sort_by_digest_4_5;
9147 opti_type = OPTI_TYPE_ZERO_BYTE
9148 | OPTI_TYPE_PRECOMPUTE_INIT
9149 | OPTI_TYPE_EARLY_SKIP
9150 | OPTI_TYPE_NOT_ITERATED
9151 | OPTI_TYPE_PREPENDED_SALT;
9152 dgst_pos0 = 3;
9153 dgst_pos1 = 4;
9154 dgst_pos2 = 2;
9155 dgst_pos3 = 1;
9156 break;
9157
9158 case 7700: hash_type = HASH_TYPE_SAPB;
9159 salt_type = SALT_TYPE_EMBEDDED;
9160 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9161 opts_type = OPTS_TYPE_PT_GENERATE_LE
9162 | OPTS_TYPE_PT_UPPER
9163 | OPTS_TYPE_ST_UPPER;
9164 kern_type = KERN_TYPE_SAPB;
9165 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9166 parse_func = sapb_parse_hash;
9167 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9168 opti_type = OPTI_TYPE_ZERO_BYTE
9169 | OPTI_TYPE_PRECOMPUTE_INIT
9170 | OPTI_TYPE_NOT_ITERATED;
9171 dgst_pos0 = 0;
9172 dgst_pos1 = 1;
9173 dgst_pos2 = 2;
9174 dgst_pos3 = 3;
9175 break;
9176
9177 case 7800: hash_type = HASH_TYPE_SAPG;
9178 salt_type = SALT_TYPE_EMBEDDED;
9179 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9180 opts_type = OPTS_TYPE_PT_GENERATE_BE
9181 | OPTS_TYPE_ST_ADD80
9182 | OPTS_TYPE_ST_UPPER;
9183 kern_type = KERN_TYPE_SAPG;
9184 dgst_size = DGST_SIZE_4_5;
9185 parse_func = sapg_parse_hash;
9186 sort_by_digest = sort_by_digest_4_5;
9187 opti_type = OPTI_TYPE_ZERO_BYTE
9188 | OPTI_TYPE_PRECOMPUTE_INIT
9189 | OPTI_TYPE_NOT_ITERATED;
9190 dgst_pos0 = 3;
9191 dgst_pos1 = 4;
9192 dgst_pos2 = 2;
9193 dgst_pos3 = 1;
9194 break;
9195
9196 case 7900: hash_type = HASH_TYPE_SHA512;
9197 salt_type = SALT_TYPE_EMBEDDED;
9198 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9199 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9200 kern_type = KERN_TYPE_DRUPAL7;
9201 dgst_size = DGST_SIZE_8_8;
9202 parse_func = drupal7_parse_hash;
9203 sort_by_digest = sort_by_digest_8_8;
9204 opti_type = OPTI_TYPE_ZERO_BYTE
9205 | OPTI_TYPE_USES_BITS_64;
9206 dgst_pos0 = 0;
9207 dgst_pos1 = 1;
9208 dgst_pos2 = 2;
9209 dgst_pos3 = 3;
9210 break;
9211
9212 case 8000: hash_type = HASH_TYPE_SHA256;
9213 salt_type = SALT_TYPE_EMBEDDED;
9214 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9215 opts_type = OPTS_TYPE_PT_GENERATE_BE
9216 | OPTS_TYPE_PT_UNICODE
9217 | OPTS_TYPE_ST_ADD80
9218 | OPTS_TYPE_ST_HEX;
9219 kern_type = KERN_TYPE_SYBASEASE;
9220 dgst_size = DGST_SIZE_4_8;
9221 parse_func = sybasease_parse_hash;
9222 sort_by_digest = sort_by_digest_4_8;
9223 opti_type = OPTI_TYPE_ZERO_BYTE
9224 | OPTI_TYPE_PRECOMPUTE_INIT
9225 | OPTI_TYPE_EARLY_SKIP
9226 | OPTI_TYPE_NOT_ITERATED
9227 | OPTI_TYPE_RAW_HASH;
9228 dgst_pos0 = 3;
9229 dgst_pos1 = 7;
9230 dgst_pos2 = 2;
9231 dgst_pos3 = 6;
9232 break;
9233
9234 case 8100: hash_type = HASH_TYPE_SHA1;
9235 salt_type = SALT_TYPE_EMBEDDED;
9236 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9237 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9238 kern_type = KERN_TYPE_NETSCALER;
9239 dgst_size = DGST_SIZE_4_5;
9240 parse_func = netscaler_parse_hash;
9241 sort_by_digest = sort_by_digest_4_5;
9242 opti_type = OPTI_TYPE_ZERO_BYTE
9243 | OPTI_TYPE_PRECOMPUTE_INIT
9244 | OPTI_TYPE_PRECOMPUTE_MERKLE
9245 | OPTI_TYPE_EARLY_SKIP
9246 | OPTI_TYPE_NOT_ITERATED
9247 | OPTI_TYPE_PREPENDED_SALT
9248 | OPTI_TYPE_RAW_HASH;
9249 dgst_pos0 = 3;
9250 dgst_pos1 = 4;
9251 dgst_pos2 = 2;
9252 dgst_pos3 = 1;
9253 break;
9254
9255 case 8200: hash_type = HASH_TYPE_SHA256;
9256 salt_type = SALT_TYPE_EMBEDDED;
9257 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9258 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9259 kern_type = KERN_TYPE_CLOUDKEY;
9260 dgst_size = DGST_SIZE_4_8;
9261 parse_func = cloudkey_parse_hash;
9262 sort_by_digest = sort_by_digest_4_8;
9263 opti_type = OPTI_TYPE_ZERO_BYTE;
9264 dgst_pos0 = 0;
9265 dgst_pos1 = 1;
9266 dgst_pos2 = 2;
9267 dgst_pos3 = 3;
9268 break;
9269
9270 case 8300: hash_type = HASH_TYPE_SHA1;
9271 salt_type = SALT_TYPE_EMBEDDED;
9272 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9273 opts_type = OPTS_TYPE_PT_GENERATE_LE
9274 | OPTS_TYPE_ST_HEX
9275 | OPTS_TYPE_ST_ADD80;
9276 kern_type = KERN_TYPE_NSEC3;
9277 dgst_size = DGST_SIZE_4_5;
9278 parse_func = nsec3_parse_hash;
9279 sort_by_digest = sort_by_digest_4_5;
9280 opti_type = OPTI_TYPE_ZERO_BYTE;
9281 dgst_pos0 = 3;
9282 dgst_pos1 = 4;
9283 dgst_pos2 = 2;
9284 dgst_pos3 = 1;
9285 break;
9286
9287 case 8400: hash_type = HASH_TYPE_SHA1;
9288 salt_type = SALT_TYPE_INTERN;
9289 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9290 opts_type = OPTS_TYPE_PT_GENERATE_BE
9291 | OPTS_TYPE_PT_ADD80
9292 | OPTS_TYPE_PT_ADDBITS15;
9293 kern_type = KERN_TYPE_WBB3;
9294 dgst_size = DGST_SIZE_4_5;
9295 parse_func = wbb3_parse_hash;
9296 sort_by_digest = sort_by_digest_4_5;
9297 opti_type = OPTI_TYPE_ZERO_BYTE
9298 | OPTI_TYPE_PRECOMPUTE_INIT
9299 | OPTI_TYPE_NOT_ITERATED;
9300 dgst_pos0 = 3;
9301 dgst_pos1 = 4;
9302 dgst_pos2 = 2;
9303 dgst_pos3 = 1;
9304 break;
9305
9306 case 8500: hash_type = HASH_TYPE_DESRACF;
9307 salt_type = SALT_TYPE_EMBEDDED;
9308 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9309 opts_type = OPTS_TYPE_PT_GENERATE_LE
9310 | OPTS_TYPE_ST_UPPER;
9311 kern_type = KERN_TYPE_RACF;
9312 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9313 parse_func = racf_parse_hash;
9314 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9315 opti_type = OPTI_TYPE_ZERO_BYTE
9316 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9317 dgst_pos0 = 0;
9318 dgst_pos1 = 1;
9319 dgst_pos2 = 2;
9320 dgst_pos3 = 3;
9321 break;
9322
9323 case 8600: hash_type = HASH_TYPE_LOTUS5;
9324 salt_type = SALT_TYPE_NONE;
9325 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9326 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9327 kern_type = KERN_TYPE_LOTUS5;
9328 dgst_size = DGST_SIZE_4_4;
9329 parse_func = lotus5_parse_hash;
9330 sort_by_digest = sort_by_digest_4_4;
9331 opti_type = OPTI_TYPE_EARLY_SKIP
9332 | OPTI_TYPE_NOT_ITERATED
9333 | OPTI_TYPE_NOT_SALTED
9334 | OPTI_TYPE_RAW_HASH;
9335 dgst_pos0 = 0;
9336 dgst_pos1 = 1;
9337 dgst_pos2 = 2;
9338 dgst_pos3 = 3;
9339 break;
9340
9341 case 8700: hash_type = HASH_TYPE_LOTUS6;
9342 salt_type = SALT_TYPE_EMBEDDED;
9343 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9344 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9345 kern_type = KERN_TYPE_LOTUS6;
9346 dgst_size = DGST_SIZE_4_4;
9347 parse_func = lotus6_parse_hash;
9348 sort_by_digest = sort_by_digest_4_4;
9349 opti_type = OPTI_TYPE_EARLY_SKIP
9350 | OPTI_TYPE_NOT_ITERATED
9351 | OPTI_TYPE_RAW_HASH;
9352 dgst_pos0 = 0;
9353 dgst_pos1 = 1;
9354 dgst_pos2 = 2;
9355 dgst_pos3 = 3;
9356 break;
9357
9358 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9359 salt_type = SALT_TYPE_EMBEDDED;
9360 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9361 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9362 kern_type = KERN_TYPE_ANDROIDFDE;
9363 dgst_size = DGST_SIZE_4_4;
9364 parse_func = androidfde_parse_hash;
9365 sort_by_digest = sort_by_digest_4_4;
9366 opti_type = OPTI_TYPE_ZERO_BYTE;
9367 dgst_pos0 = 0;
9368 dgst_pos1 = 1;
9369 dgst_pos2 = 2;
9370 dgst_pos3 = 3;
9371 break;
9372
9373 case 8900: hash_type = HASH_TYPE_SCRYPT;
9374 salt_type = SALT_TYPE_EMBEDDED;
9375 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9376 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9377 kern_type = KERN_TYPE_SCRYPT;
9378 dgst_size = DGST_SIZE_4_8;
9379 parse_func = scrypt_parse_hash;
9380 sort_by_digest = sort_by_digest_4_8;
9381 opti_type = OPTI_TYPE_ZERO_BYTE;
9382 dgst_pos0 = 0;
9383 dgst_pos1 = 1;
9384 dgst_pos2 = 2;
9385 dgst_pos3 = 3;
9386 break;
9387
9388 case 9000: hash_type = HASH_TYPE_SHA1;
9389 salt_type = SALT_TYPE_EMBEDDED;
9390 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9391 opts_type = OPTS_TYPE_PT_GENERATE_LE
9392 | OPTS_TYPE_ST_GENERATE_LE;
9393 kern_type = KERN_TYPE_PSAFE2;
9394 dgst_size = DGST_SIZE_4_5;
9395 parse_func = psafe2_parse_hash;
9396 sort_by_digest = sort_by_digest_4_5;
9397 opti_type = OPTI_TYPE_ZERO_BYTE;
9398 dgst_pos0 = 0;
9399 dgst_pos1 = 1;
9400 dgst_pos2 = 2;
9401 dgst_pos3 = 3;
9402 break;
9403
9404 case 9100: hash_type = HASH_TYPE_LOTUS8;
9405 salt_type = SALT_TYPE_EMBEDDED;
9406 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9407 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9408 kern_type = KERN_TYPE_LOTUS8;
9409 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9410 parse_func = lotus8_parse_hash;
9411 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9412 opti_type = OPTI_TYPE_ZERO_BYTE;
9413 dgst_pos0 = 0;
9414 dgst_pos1 = 1;
9415 dgst_pos2 = 2;
9416 dgst_pos3 = 3;
9417 break;
9418
9419 case 9200: hash_type = HASH_TYPE_SHA256;
9420 salt_type = SALT_TYPE_EMBEDDED;
9421 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9422 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9423 kern_type = KERN_TYPE_PBKDF2_SHA256;
9424 dgst_size = DGST_SIZE_4_32;
9425 parse_func = cisco8_parse_hash;
9426 sort_by_digest = sort_by_digest_4_32;
9427 opti_type = OPTI_TYPE_ZERO_BYTE;
9428 dgst_pos0 = 0;
9429 dgst_pos1 = 1;
9430 dgst_pos2 = 2;
9431 dgst_pos3 = 3;
9432 break;
9433
9434 case 9300: hash_type = HASH_TYPE_SCRYPT;
9435 salt_type = SALT_TYPE_EMBEDDED;
9436 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9437 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9438 kern_type = KERN_TYPE_SCRYPT;
9439 dgst_size = DGST_SIZE_4_8;
9440 parse_func = cisco9_parse_hash;
9441 sort_by_digest = sort_by_digest_4_8;
9442 opti_type = OPTI_TYPE_ZERO_BYTE;
9443 dgst_pos0 = 0;
9444 dgst_pos1 = 1;
9445 dgst_pos2 = 2;
9446 dgst_pos3 = 3;
9447 break;
9448
9449 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9450 salt_type = SALT_TYPE_EMBEDDED;
9451 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9452 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9453 kern_type = KERN_TYPE_OFFICE2007;
9454 dgst_size = DGST_SIZE_4_4;
9455 parse_func = office2007_parse_hash;
9456 sort_by_digest = sort_by_digest_4_4;
9457 opti_type = OPTI_TYPE_ZERO_BYTE;
9458 dgst_pos0 = 0;
9459 dgst_pos1 = 1;
9460 dgst_pos2 = 2;
9461 dgst_pos3 = 3;
9462 break;
9463
9464 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9465 salt_type = SALT_TYPE_EMBEDDED;
9466 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9467 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9468 kern_type = KERN_TYPE_OFFICE2010;
9469 dgst_size = DGST_SIZE_4_4;
9470 parse_func = office2010_parse_hash;
9471 sort_by_digest = sort_by_digest_4_4;
9472 opti_type = OPTI_TYPE_ZERO_BYTE;
9473 dgst_pos0 = 0;
9474 dgst_pos1 = 1;
9475 dgst_pos2 = 2;
9476 dgst_pos3 = 3;
9477 break;
9478
9479 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9480 salt_type = SALT_TYPE_EMBEDDED;
9481 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9482 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9483 kern_type = KERN_TYPE_OFFICE2013;
9484 dgst_size = DGST_SIZE_4_4;
9485 parse_func = office2013_parse_hash;
9486 sort_by_digest = sort_by_digest_4_4;
9487 opti_type = OPTI_TYPE_ZERO_BYTE;
9488 dgst_pos0 = 0;
9489 dgst_pos1 = 1;
9490 dgst_pos2 = 2;
9491 dgst_pos3 = 3;
9492 break;
9493
9494 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9495 salt_type = SALT_TYPE_EMBEDDED;
9496 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9497 opts_type = OPTS_TYPE_PT_GENERATE_LE
9498 | OPTS_TYPE_PT_ADD80
9499 | OPTS_TYPE_PT_UNICODE;
9500 kern_type = KERN_TYPE_OLDOFFICE01;
9501 dgst_size = DGST_SIZE_4_4;
9502 parse_func = oldoffice01_parse_hash;
9503 sort_by_digest = sort_by_digest_4_4;
9504 opti_type = OPTI_TYPE_ZERO_BYTE
9505 | OPTI_TYPE_PRECOMPUTE_INIT
9506 | OPTI_TYPE_NOT_ITERATED;
9507 dgst_pos0 = 0;
9508 dgst_pos1 = 1;
9509 dgst_pos2 = 2;
9510 dgst_pos3 = 3;
9511 break;
9512
9513 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9514 salt_type = SALT_TYPE_EMBEDDED;
9515 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9516 opts_type = OPTS_TYPE_PT_GENERATE_LE
9517 | OPTS_TYPE_PT_ADD80;
9518 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9519 dgst_size = DGST_SIZE_4_4;
9520 parse_func = oldoffice01cm1_parse_hash;
9521 sort_by_digest = sort_by_digest_4_4;
9522 opti_type = OPTI_TYPE_ZERO_BYTE
9523 | OPTI_TYPE_PRECOMPUTE_INIT
9524 | OPTI_TYPE_NOT_ITERATED;
9525 dgst_pos0 = 0;
9526 dgst_pos1 = 1;
9527 dgst_pos2 = 2;
9528 dgst_pos3 = 3;
9529 break;
9530
9531 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9532 salt_type = SALT_TYPE_EMBEDDED;
9533 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9534 opts_type = OPTS_TYPE_PT_GENERATE_LE
9535 | OPTS_TYPE_PT_ADD80
9536 | OPTS_TYPE_PT_UNICODE
9537 | OPTS_TYPE_PT_NEVERCRACK;
9538 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9539 dgst_size = DGST_SIZE_4_4;
9540 parse_func = oldoffice01cm2_parse_hash;
9541 sort_by_digest = sort_by_digest_4_4;
9542 opti_type = OPTI_TYPE_ZERO_BYTE
9543 | OPTI_TYPE_PRECOMPUTE_INIT
9544 | OPTI_TYPE_NOT_ITERATED;
9545 dgst_pos0 = 0;
9546 dgst_pos1 = 1;
9547 dgst_pos2 = 2;
9548 dgst_pos3 = 3;
9549 break;
9550
9551 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9552 salt_type = SALT_TYPE_EMBEDDED;
9553 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9554 opts_type = OPTS_TYPE_PT_GENERATE_BE
9555 | OPTS_TYPE_PT_ADD80
9556 | OPTS_TYPE_PT_UNICODE;
9557 kern_type = KERN_TYPE_OLDOFFICE34;
9558 dgst_size = DGST_SIZE_4_4;
9559 parse_func = oldoffice34_parse_hash;
9560 sort_by_digest = sort_by_digest_4_4;
9561 opti_type = OPTI_TYPE_ZERO_BYTE
9562 | OPTI_TYPE_PRECOMPUTE_INIT
9563 | OPTI_TYPE_NOT_ITERATED;
9564 dgst_pos0 = 0;
9565 dgst_pos1 = 1;
9566 dgst_pos2 = 2;
9567 dgst_pos3 = 3;
9568 break;
9569
9570 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9571 salt_type = SALT_TYPE_EMBEDDED;
9572 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9573 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9574 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9575 dgst_size = DGST_SIZE_4_4;
9576 parse_func = oldoffice34cm1_parse_hash;
9577 sort_by_digest = sort_by_digest_4_4;
9578 opti_type = OPTI_TYPE_ZERO_BYTE
9579 | OPTI_TYPE_PRECOMPUTE_INIT
9580 | OPTI_TYPE_NOT_ITERATED;
9581 dgst_pos0 = 0;
9582 dgst_pos1 = 1;
9583 dgst_pos2 = 2;
9584 dgst_pos3 = 3;
9585 break;
9586
9587 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9588 salt_type = SALT_TYPE_EMBEDDED;
9589 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9590 opts_type = OPTS_TYPE_PT_GENERATE_BE
9591 | OPTS_TYPE_PT_ADD80
9592 | OPTS_TYPE_PT_UNICODE
9593 | OPTS_TYPE_PT_NEVERCRACK;
9594 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9595 dgst_size = DGST_SIZE_4_4;
9596 parse_func = oldoffice34cm2_parse_hash;
9597 sort_by_digest = sort_by_digest_4_4;
9598 opti_type = OPTI_TYPE_ZERO_BYTE
9599 | OPTI_TYPE_PRECOMPUTE_INIT
9600 | OPTI_TYPE_NOT_ITERATED;
9601 dgst_pos0 = 0;
9602 dgst_pos1 = 1;
9603 dgst_pos2 = 2;
9604 dgst_pos3 = 3;
9605 break;
9606
9607 case 9900: hash_type = HASH_TYPE_MD5;
9608 salt_type = SALT_TYPE_NONE;
9609 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9610 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9611 kern_type = KERN_TYPE_RADMIN2;
9612 dgst_size = DGST_SIZE_4_4;
9613 parse_func = radmin2_parse_hash;
9614 sort_by_digest = sort_by_digest_4_4;
9615 opti_type = OPTI_TYPE_ZERO_BYTE
9616 | OPTI_TYPE_PRECOMPUTE_INIT
9617 | OPTI_TYPE_EARLY_SKIP
9618 | OPTI_TYPE_NOT_ITERATED
9619 | OPTI_TYPE_NOT_SALTED;
9620 dgst_pos0 = 0;
9621 dgst_pos1 = 3;
9622 dgst_pos2 = 2;
9623 dgst_pos3 = 1;
9624 break;
9625
9626 case 10000: hash_type = HASH_TYPE_SHA256;
9627 salt_type = SALT_TYPE_EMBEDDED;
9628 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9629 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9630 kern_type = KERN_TYPE_PBKDF2_SHA256;
9631 dgst_size = DGST_SIZE_4_32;
9632 parse_func = djangopbkdf2_parse_hash;
9633 sort_by_digest = sort_by_digest_4_32;
9634 opti_type = OPTI_TYPE_ZERO_BYTE;
9635 dgst_pos0 = 0;
9636 dgst_pos1 = 1;
9637 dgst_pos2 = 2;
9638 dgst_pos3 = 3;
9639 break;
9640
9641 case 10100: hash_type = HASH_TYPE_SIPHASH;
9642 salt_type = SALT_TYPE_EMBEDDED;
9643 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9644 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9645 kern_type = KERN_TYPE_SIPHASH;
9646 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9647 parse_func = siphash_parse_hash;
9648 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9649 opti_type = OPTI_TYPE_ZERO_BYTE
9650 | OPTI_TYPE_NOT_ITERATED
9651 | OPTI_TYPE_RAW_HASH;
9652 dgst_pos0 = 0;
9653 dgst_pos1 = 1;
9654 dgst_pos2 = 2;
9655 dgst_pos3 = 3;
9656 break;
9657
9658 case 10200: hash_type = HASH_TYPE_MD5;
9659 salt_type = SALT_TYPE_EMBEDDED;
9660 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9661 opts_type = OPTS_TYPE_PT_GENERATE_LE
9662 | OPTS_TYPE_ST_ADD80
9663 | OPTS_TYPE_ST_ADDBITS14;
9664 kern_type = KERN_TYPE_HMACMD5_PW;
9665 dgst_size = DGST_SIZE_4_4;
9666 parse_func = crammd5_parse_hash;
9667 sort_by_digest = sort_by_digest_4_4;
9668 opti_type = OPTI_TYPE_ZERO_BYTE
9669 | OPTI_TYPE_NOT_ITERATED;
9670 dgst_pos0 = 0;
9671 dgst_pos1 = 3;
9672 dgst_pos2 = 2;
9673 dgst_pos3 = 1;
9674 break;
9675
9676 case 10300: hash_type = HASH_TYPE_SHA1;
9677 salt_type = SALT_TYPE_EMBEDDED;
9678 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9679 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9680 kern_type = KERN_TYPE_SAPH_SHA1;
9681 dgst_size = DGST_SIZE_4_5;
9682 parse_func = saph_sha1_parse_hash;
9683 sort_by_digest = sort_by_digest_4_5;
9684 opti_type = OPTI_TYPE_ZERO_BYTE;
9685 dgst_pos0 = 0;
9686 dgst_pos1 = 1;
9687 dgst_pos2 = 2;
9688 dgst_pos3 = 3;
9689 break;
9690
9691 case 10400: hash_type = HASH_TYPE_PDFU16;
9692 salt_type = SALT_TYPE_EMBEDDED;
9693 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9694 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9695 kern_type = KERN_TYPE_PDF11;
9696 dgst_size = DGST_SIZE_4_4;
9697 parse_func = pdf11_parse_hash;
9698 sort_by_digest = sort_by_digest_4_4;
9699 opti_type = OPTI_TYPE_ZERO_BYTE
9700 | OPTI_TYPE_NOT_ITERATED;
9701 dgst_pos0 = 0;
9702 dgst_pos1 = 1;
9703 dgst_pos2 = 2;
9704 dgst_pos3 = 3;
9705 break;
9706
9707 case 10410: hash_type = HASH_TYPE_PDFU16;
9708 salt_type = SALT_TYPE_EMBEDDED;
9709 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9710 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9711 kern_type = KERN_TYPE_PDF11CM1;
9712 dgst_size = DGST_SIZE_4_4;
9713 parse_func = pdf11cm1_parse_hash;
9714 sort_by_digest = sort_by_digest_4_4;
9715 opti_type = OPTI_TYPE_ZERO_BYTE
9716 | OPTI_TYPE_NOT_ITERATED;
9717 dgst_pos0 = 0;
9718 dgst_pos1 = 1;
9719 dgst_pos2 = 2;
9720 dgst_pos3 = 3;
9721 break;
9722
9723 case 10420: hash_type = HASH_TYPE_PDFU16;
9724 salt_type = SALT_TYPE_EMBEDDED;
9725 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9726 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9727 kern_type = KERN_TYPE_PDF11CM2;
9728 dgst_size = DGST_SIZE_4_4;
9729 parse_func = pdf11cm2_parse_hash;
9730 sort_by_digest = sort_by_digest_4_4;
9731 opti_type = OPTI_TYPE_ZERO_BYTE
9732 | OPTI_TYPE_NOT_ITERATED;
9733 dgst_pos0 = 0;
9734 dgst_pos1 = 1;
9735 dgst_pos2 = 2;
9736 dgst_pos3 = 3;
9737 break;
9738
9739 case 10500: hash_type = HASH_TYPE_PDFU16;
9740 salt_type = SALT_TYPE_EMBEDDED;
9741 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9742 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9743 kern_type = KERN_TYPE_PDF14;
9744 dgst_size = DGST_SIZE_4_4;
9745 parse_func = pdf14_parse_hash;
9746 sort_by_digest = sort_by_digest_4_4;
9747 opti_type = OPTI_TYPE_ZERO_BYTE
9748 | OPTI_TYPE_NOT_ITERATED;
9749 dgst_pos0 = 0;
9750 dgst_pos1 = 1;
9751 dgst_pos2 = 2;
9752 dgst_pos3 = 3;
9753 break;
9754
9755 case 10600: hash_type = HASH_TYPE_SHA256;
9756 salt_type = SALT_TYPE_EMBEDDED;
9757 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9758 opts_type = OPTS_TYPE_PT_GENERATE_BE
9759 | OPTS_TYPE_ST_ADD80
9760 | OPTS_TYPE_ST_ADDBITS15
9761 | OPTS_TYPE_HASH_COPY;
9762 kern_type = KERN_TYPE_SHA256_PWSLT;
9763 dgst_size = DGST_SIZE_4_8;
9764 parse_func = pdf17l3_parse_hash;
9765 sort_by_digest = sort_by_digest_4_8;
9766 opti_type = OPTI_TYPE_ZERO_BYTE
9767 | OPTI_TYPE_PRECOMPUTE_INIT
9768 | OPTI_TYPE_PRECOMPUTE_MERKLE
9769 | OPTI_TYPE_EARLY_SKIP
9770 | OPTI_TYPE_NOT_ITERATED
9771 | OPTI_TYPE_APPENDED_SALT
9772 | OPTI_TYPE_RAW_HASH;
9773 dgst_pos0 = 3;
9774 dgst_pos1 = 7;
9775 dgst_pos2 = 2;
9776 dgst_pos3 = 6;
9777 break;
9778
9779 case 10700: hash_type = HASH_TYPE_PDFU32;
9780 salt_type = SALT_TYPE_EMBEDDED;
9781 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9782 opts_type = OPTS_TYPE_PT_GENERATE_LE
9783 | OPTS_TYPE_HASH_COPY;
9784 kern_type = KERN_TYPE_PDF17L8;
9785 dgst_size = DGST_SIZE_4_8;
9786 parse_func = pdf17l8_parse_hash;
9787 sort_by_digest = sort_by_digest_4_8;
9788 opti_type = OPTI_TYPE_ZERO_BYTE
9789 | OPTI_TYPE_NOT_ITERATED;
9790 dgst_pos0 = 0;
9791 dgst_pos1 = 1;
9792 dgst_pos2 = 2;
9793 dgst_pos3 = 3;
9794 break;
9795
9796 case 10800: hash_type = HASH_TYPE_SHA384;
9797 salt_type = SALT_TYPE_NONE;
9798 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9799 opts_type = OPTS_TYPE_PT_GENERATE_BE
9800 | OPTS_TYPE_PT_ADD80
9801 | OPTS_TYPE_PT_ADDBITS15;
9802 kern_type = KERN_TYPE_SHA384;
9803 dgst_size = DGST_SIZE_8_8;
9804 parse_func = sha384_parse_hash;
9805 sort_by_digest = sort_by_digest_8_8;
9806 opti_type = OPTI_TYPE_ZERO_BYTE
9807 | OPTI_TYPE_PRECOMPUTE_INIT
9808 | OPTI_TYPE_PRECOMPUTE_MERKLE
9809 | OPTI_TYPE_EARLY_SKIP
9810 | OPTI_TYPE_NOT_ITERATED
9811 | OPTI_TYPE_NOT_SALTED
9812 | OPTI_TYPE_USES_BITS_64
9813 | OPTI_TYPE_RAW_HASH;
9814 dgst_pos0 = 6;
9815 dgst_pos1 = 7;
9816 dgst_pos2 = 4;
9817 dgst_pos3 = 5;
9818 break;
9819
9820 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9821 salt_type = SALT_TYPE_EMBEDDED;
9822 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9823 opts_type = OPTS_TYPE_PT_GENERATE_LE
9824 | OPTS_TYPE_ST_BASE64
9825 | OPTS_TYPE_HASH_COPY;
9826 kern_type = KERN_TYPE_PBKDF2_SHA256;
9827 dgst_size = DGST_SIZE_4_32;
9828 parse_func = pbkdf2_sha256_parse_hash;
9829 sort_by_digest = sort_by_digest_4_32;
9830 opti_type = OPTI_TYPE_ZERO_BYTE;
9831 dgst_pos0 = 0;
9832 dgst_pos1 = 1;
9833 dgst_pos2 = 2;
9834 dgst_pos3 = 3;
9835 break;
9836
9837 case 11000: hash_type = HASH_TYPE_MD5;
9838 salt_type = SALT_TYPE_INTERN;
9839 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9840 opts_type = OPTS_TYPE_PT_GENERATE_LE
9841 | OPTS_TYPE_PT_ADD80;
9842 kern_type = KERN_TYPE_PRESTASHOP;
9843 dgst_size = DGST_SIZE_4_4;
9844 parse_func = prestashop_parse_hash;
9845 sort_by_digest = sort_by_digest_4_4;
9846 opti_type = OPTI_TYPE_ZERO_BYTE
9847 | OPTI_TYPE_PRECOMPUTE_INIT
9848 | OPTI_TYPE_NOT_ITERATED
9849 | OPTI_TYPE_PREPENDED_SALT;
9850 dgst_pos0 = 0;
9851 dgst_pos1 = 3;
9852 dgst_pos2 = 2;
9853 dgst_pos3 = 1;
9854 break;
9855
9856 case 11100: hash_type = HASH_TYPE_MD5;
9857 salt_type = SALT_TYPE_EMBEDDED;
9858 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9859 opts_type = OPTS_TYPE_PT_GENERATE_LE
9860 | OPTS_TYPE_ST_ADD80;
9861 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9862 dgst_size = DGST_SIZE_4_4;
9863 parse_func = postgresql_auth_parse_hash;
9864 sort_by_digest = sort_by_digest_4_4;
9865 opti_type = OPTI_TYPE_ZERO_BYTE
9866 | OPTI_TYPE_PRECOMPUTE_INIT
9867 | OPTI_TYPE_PRECOMPUTE_MERKLE
9868 | OPTI_TYPE_EARLY_SKIP;
9869 dgst_pos0 = 0;
9870 dgst_pos1 = 3;
9871 dgst_pos2 = 2;
9872 dgst_pos3 = 1;
9873 break;
9874
9875 case 11200: hash_type = HASH_TYPE_SHA1;
9876 salt_type = SALT_TYPE_EMBEDDED;
9877 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9878 opts_type = OPTS_TYPE_PT_GENERATE_BE
9879 | OPTS_TYPE_PT_ADD80
9880 | OPTS_TYPE_ST_HEX;
9881 kern_type = KERN_TYPE_MYSQL_AUTH;
9882 dgst_size = DGST_SIZE_4_5;
9883 parse_func = mysql_auth_parse_hash;
9884 sort_by_digest = sort_by_digest_4_5;
9885 opti_type = OPTI_TYPE_ZERO_BYTE
9886 | OPTI_TYPE_EARLY_SKIP;
9887 dgst_pos0 = 3;
9888 dgst_pos1 = 4;
9889 dgst_pos2 = 2;
9890 dgst_pos3 = 1;
9891 break;
9892
9893 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9894 salt_type = SALT_TYPE_EMBEDDED;
9895 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9896 opts_type = OPTS_TYPE_PT_GENERATE_LE
9897 | OPTS_TYPE_ST_HEX
9898 | OPTS_TYPE_ST_ADD80;
9899 kern_type = KERN_TYPE_BITCOIN_WALLET;
9900 dgst_size = DGST_SIZE_4_4;
9901 parse_func = bitcoin_wallet_parse_hash;
9902 sort_by_digest = sort_by_digest_4_4;
9903 opti_type = OPTI_TYPE_ZERO_BYTE;
9904 dgst_pos0 = 0;
9905 dgst_pos1 = 1;
9906 dgst_pos2 = 2;
9907 dgst_pos3 = 3;
9908 break;
9909
9910 case 11400: hash_type = HASH_TYPE_MD5;
9911 salt_type = SALT_TYPE_EMBEDDED;
9912 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9913 opts_type = OPTS_TYPE_PT_GENERATE_LE
9914 | OPTS_TYPE_PT_ADD80
9915 | OPTS_TYPE_HASH_COPY;
9916 kern_type = KERN_TYPE_SIP_AUTH;
9917 dgst_size = DGST_SIZE_4_4;
9918 parse_func = sip_auth_parse_hash;
9919 sort_by_digest = sort_by_digest_4_4;
9920 opti_type = OPTI_TYPE_ZERO_BYTE;
9921 dgst_pos0 = 0;
9922 dgst_pos1 = 3;
9923 dgst_pos2 = 2;
9924 dgst_pos3 = 1;
9925 break;
9926
9927 case 11500: hash_type = HASH_TYPE_CRC32;
9928 salt_type = SALT_TYPE_INTERN;
9929 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9930 opts_type = OPTS_TYPE_PT_GENERATE_LE
9931 | OPTS_TYPE_ST_GENERATE_LE
9932 | OPTS_TYPE_ST_HEX;
9933 kern_type = KERN_TYPE_CRC32;
9934 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9935 parse_func = crc32_parse_hash;
9936 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9937 opti_type = OPTI_TYPE_ZERO_BYTE;
9938 dgst_pos0 = 0;
9939 dgst_pos1 = 1;
9940 dgst_pos2 = 2;
9941 dgst_pos3 = 3;
9942 break;
9943
9944 case 11600: hash_type = HASH_TYPE_AES;
9945 salt_type = SALT_TYPE_EMBEDDED;
9946 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9947 opts_type = OPTS_TYPE_PT_GENERATE_LE
9948 | OPTS_TYPE_PT_NEVERCRACK;
9949 kern_type = KERN_TYPE_SEVEN_ZIP;
9950 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9951 parse_func = seven_zip_parse_hash;
9952 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9953 opti_type = OPTI_TYPE_ZERO_BYTE;
9954 dgst_pos0 = 0;
9955 dgst_pos1 = 1;
9956 dgst_pos2 = 2;
9957 dgst_pos3 = 3;
9958 break;
9959
9960 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9961 salt_type = SALT_TYPE_NONE;
9962 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9963 opts_type = OPTS_TYPE_PT_GENERATE_LE
9964 | OPTS_TYPE_PT_ADD01;
9965 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9966 dgst_size = DGST_SIZE_4_8;
9967 parse_func = gost2012sbog_256_parse_hash;
9968 sort_by_digest = sort_by_digest_4_8;
9969 opti_type = OPTI_TYPE_ZERO_BYTE;
9970 dgst_pos0 = 0;
9971 dgst_pos1 = 1;
9972 dgst_pos2 = 2;
9973 dgst_pos3 = 3;
9974 break;
9975
9976 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
9977 salt_type = SALT_TYPE_NONE;
9978 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9979 opts_type = OPTS_TYPE_PT_GENERATE_LE
9980 | OPTS_TYPE_PT_ADD01;
9981 kern_type = KERN_TYPE_GOST_2012SBOG_512;
9982 dgst_size = DGST_SIZE_4_16;
9983 parse_func = gost2012sbog_512_parse_hash;
9984 sort_by_digest = sort_by_digest_4_16;
9985 opti_type = OPTI_TYPE_ZERO_BYTE;
9986 dgst_pos0 = 0;
9987 dgst_pos1 = 1;
9988 dgst_pos2 = 2;
9989 dgst_pos3 = 3;
9990 break;
9991
9992 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
9993 salt_type = SALT_TYPE_EMBEDDED;
9994 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9995 opts_type = OPTS_TYPE_PT_GENERATE_LE
9996 | OPTS_TYPE_ST_BASE64
9997 | OPTS_TYPE_HASH_COPY;
9998 kern_type = KERN_TYPE_PBKDF2_MD5;
9999 dgst_size = DGST_SIZE_4_32;
10000 parse_func = pbkdf2_md5_parse_hash;
10001 sort_by_digest = sort_by_digest_4_32;
10002 opti_type = OPTI_TYPE_ZERO_BYTE;
10003 dgst_pos0 = 0;
10004 dgst_pos1 = 1;
10005 dgst_pos2 = 2;
10006 dgst_pos3 = 3;
10007 break;
10008
10009 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10010 salt_type = SALT_TYPE_EMBEDDED;
10011 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10012 opts_type = OPTS_TYPE_PT_GENERATE_LE
10013 | OPTS_TYPE_ST_BASE64
10014 | OPTS_TYPE_HASH_COPY;
10015 kern_type = KERN_TYPE_PBKDF2_SHA1;
10016 dgst_size = DGST_SIZE_4_32;
10017 parse_func = pbkdf2_sha1_parse_hash;
10018 sort_by_digest = sort_by_digest_4_32;
10019 opti_type = OPTI_TYPE_ZERO_BYTE;
10020 dgst_pos0 = 0;
10021 dgst_pos1 = 1;
10022 dgst_pos2 = 2;
10023 dgst_pos3 = 3;
10024 break;
10025
10026 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10027 salt_type = SALT_TYPE_EMBEDDED;
10028 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10029 opts_type = OPTS_TYPE_PT_GENERATE_LE
10030 | OPTS_TYPE_ST_BASE64
10031 | OPTS_TYPE_HASH_COPY;
10032 kern_type = KERN_TYPE_PBKDF2_SHA512;
10033 dgst_size = DGST_SIZE_8_16;
10034 parse_func = pbkdf2_sha512_parse_hash;
10035 sort_by_digest = sort_by_digest_8_16;
10036 opti_type = OPTI_TYPE_ZERO_BYTE
10037 | OPTI_TYPE_USES_BITS_64;
10038 dgst_pos0 = 0;
10039 dgst_pos1 = 1;
10040 dgst_pos2 = 2;
10041 dgst_pos3 = 3;
10042 break;
10043
10044 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10045 salt_type = SALT_TYPE_EMBEDDED;
10046 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10047 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10048 kern_type = KERN_TYPE_ECRYPTFS;
10049 dgst_size = DGST_SIZE_8_8;
10050 parse_func = ecryptfs_parse_hash;
10051 sort_by_digest = sort_by_digest_8_8;
10052 opti_type = OPTI_TYPE_ZERO_BYTE
10053 | OPTI_TYPE_USES_BITS_64;
10054 dgst_pos0 = 0;
10055 dgst_pos1 = 1;
10056 dgst_pos2 = 2;
10057 dgst_pos3 = 3;
10058 break;
10059
10060 case 12300: hash_type = HASH_TYPE_ORACLET;
10061 salt_type = SALT_TYPE_EMBEDDED;
10062 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10063 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10064 kern_type = KERN_TYPE_ORACLET;
10065 dgst_size = DGST_SIZE_8_16;
10066 parse_func = oraclet_parse_hash;
10067 sort_by_digest = sort_by_digest_8_16;
10068 opti_type = OPTI_TYPE_ZERO_BYTE
10069 | OPTI_TYPE_USES_BITS_64;
10070 dgst_pos0 = 0;
10071 dgst_pos1 = 1;
10072 dgst_pos2 = 2;
10073 dgst_pos3 = 3;
10074 break;
10075
10076 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10077 salt_type = SALT_TYPE_EMBEDDED;
10078 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10079 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10080 kern_type = KERN_TYPE_BSDICRYPT;
10081 dgst_size = DGST_SIZE_4_4;
10082 parse_func = bsdicrypt_parse_hash;
10083 sort_by_digest = sort_by_digest_4_4;
10084 opti_type = OPTI_TYPE_ZERO_BYTE
10085 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10086 dgst_pos0 = 0;
10087 dgst_pos1 = 1;
10088 dgst_pos2 = 2;
10089 dgst_pos3 = 3;
10090 break;
10091
10092 case 12500: hash_type = HASH_TYPE_RAR3HP;
10093 salt_type = SALT_TYPE_EMBEDDED;
10094 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10095 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10096 kern_type = KERN_TYPE_RAR3;
10097 dgst_size = DGST_SIZE_4_4;
10098 parse_func = rar3hp_parse_hash;
10099 sort_by_digest = sort_by_digest_4_4;
10100 opti_type = OPTI_TYPE_ZERO_BYTE;
10101 dgst_pos0 = 0;
10102 dgst_pos1 = 1;
10103 dgst_pos2 = 2;
10104 dgst_pos3 = 3;
10105 break;
10106
10107 case 12600: hash_type = HASH_TYPE_SHA256;
10108 salt_type = SALT_TYPE_INTERN;
10109 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10110 opts_type = OPTS_TYPE_PT_GENERATE_BE
10111 | OPTS_TYPE_PT_ADD80;
10112 kern_type = KERN_TYPE_CF10;
10113 dgst_size = DGST_SIZE_4_8;
10114 parse_func = cf10_parse_hash;
10115 sort_by_digest = sort_by_digest_4_8;
10116 opti_type = OPTI_TYPE_ZERO_BYTE
10117 | OPTI_TYPE_PRECOMPUTE_INIT
10118 | OPTI_TYPE_EARLY_SKIP
10119 | OPTI_TYPE_NOT_ITERATED;
10120 dgst_pos0 = 3;
10121 dgst_pos1 = 7;
10122 dgst_pos2 = 2;
10123 dgst_pos3 = 6;
10124 break;
10125
10126 case 12700: hash_type = HASH_TYPE_AES;
10127 salt_type = SALT_TYPE_EMBEDDED;
10128 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10129 opts_type = OPTS_TYPE_PT_GENERATE_LE
10130 | OPTS_TYPE_HASH_COPY;
10131 kern_type = KERN_TYPE_MYWALLET;
10132 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10133 parse_func = mywallet_parse_hash;
10134 sort_by_digest = sort_by_digest_4_5;
10135 opti_type = OPTI_TYPE_ZERO_BYTE;
10136 dgst_pos0 = 0;
10137 dgst_pos1 = 1;
10138 dgst_pos2 = 2;
10139 dgst_pos3 = 3;
10140 break;
10141
10142 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10143 salt_type = SALT_TYPE_EMBEDDED;
10144 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10145 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10146 kern_type = KERN_TYPE_MS_DRSR;
10147 dgst_size = DGST_SIZE_4_8;
10148 parse_func = ms_drsr_parse_hash;
10149 sort_by_digest = sort_by_digest_4_8;
10150 opti_type = OPTI_TYPE_ZERO_BYTE;
10151 dgst_pos0 = 0;
10152 dgst_pos1 = 1;
10153 dgst_pos2 = 2;
10154 dgst_pos3 = 3;
10155 break;
10156
10157 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10158 salt_type = SALT_TYPE_EMBEDDED;
10159 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10160 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10161 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10162 dgst_size = DGST_SIZE_4_8;
10163 parse_func = androidfde_samsung_parse_hash;
10164 sort_by_digest = sort_by_digest_4_8;
10165 opti_type = OPTI_TYPE_ZERO_BYTE;
10166 dgst_pos0 = 0;
10167 dgst_pos1 = 1;
10168 dgst_pos2 = 2;
10169 dgst_pos3 = 3;
10170 break;
10171
10172 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10173 salt_type = SALT_TYPE_EMBEDDED;
10174 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10175 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10176 kern_type = KERN_TYPE_RAR5;
10177 dgst_size = DGST_SIZE_4_4;
10178 parse_func = rar5_parse_hash;
10179 sort_by_digest = sort_by_digest_4_4;
10180 opti_type = OPTI_TYPE_ZERO_BYTE;
10181 dgst_pos0 = 0;
10182 dgst_pos1 = 1;
10183 dgst_pos2 = 2;
10184 dgst_pos3 = 3;
10185 break;
10186
10187 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10188 salt_type = SALT_TYPE_EMBEDDED;
10189 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10190 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10191 kern_type = KERN_TYPE_KRB5TGS;
10192 dgst_size = DGST_SIZE_4_4;
10193 parse_func = krb5tgs_parse_hash;
10194 sort_by_digest = sort_by_digest_4_4;
10195 opti_type = OPTI_TYPE_ZERO_BYTE
10196 | OPTI_TYPE_NOT_ITERATED;
10197 dgst_pos0 = 0;
10198 dgst_pos1 = 1;
10199 dgst_pos2 = 2;
10200 dgst_pos3 = 3;
10201 break;
10202
10203 default: usage_mini_print (PROGNAME); return (-1);
10204 }
10205
10206 /**
10207 * parser
10208 */
10209
10210 data.parse_func = parse_func;
10211
10212 /**
10213 * misc stuff
10214 */
10215
10216 if (hex_salt)
10217 {
10218 if (salt_type == SALT_TYPE_INTERN)
10219 {
10220 opts_type |= OPTS_TYPE_ST_HEX;
10221 }
10222 else
10223 {
10224 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10225
10226 return (-1);
10227 }
10228 }
10229
10230 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10231 | (salt_type == SALT_TYPE_EXTERN)
10232 | (salt_type == SALT_TYPE_EMBEDDED)
10233 | (salt_type == SALT_TYPE_VIRTUAL));
10234
10235 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10236
10237 data.hash_type = hash_type;
10238 data.attack_mode = attack_mode;
10239 data.attack_kern = attack_kern;
10240 data.attack_exec = attack_exec;
10241 data.kern_type = kern_type;
10242 data.opts_type = opts_type;
10243 data.dgst_size = dgst_size;
10244 data.salt_type = salt_type;
10245 data.isSalted = isSalted;
10246 data.sort_by_digest = sort_by_digest;
10247 data.dgst_pos0 = dgst_pos0;
10248 data.dgst_pos1 = dgst_pos1;
10249 data.dgst_pos2 = dgst_pos2;
10250 data.dgst_pos3 = dgst_pos3;
10251
10252 esalt_size = 0;
10253
10254 switch (hash_mode)
10255 {
10256 case 2500: esalt_size = sizeof (wpa_t); break;
10257 case 5300: esalt_size = sizeof (ikepsk_t); break;
10258 case 5400: esalt_size = sizeof (ikepsk_t); break;
10259 case 5500: esalt_size = sizeof (netntlm_t); break;
10260 case 5600: esalt_size = sizeof (netntlm_t); break;
10261 case 6211: esalt_size = sizeof (tc_t); break;
10262 case 6212: esalt_size = sizeof (tc_t); break;
10263 case 6213: esalt_size = sizeof (tc_t); break;
10264 case 6221: esalt_size = sizeof (tc_t); break;
10265 case 6222: esalt_size = sizeof (tc_t); break;
10266 case 6223: esalt_size = sizeof (tc_t); break;
10267 case 6231: esalt_size = sizeof (tc_t); break;
10268 case 6232: esalt_size = sizeof (tc_t); break;
10269 case 6233: esalt_size = sizeof (tc_t); break;
10270 case 6241: esalt_size = sizeof (tc_t); break;
10271 case 6242: esalt_size = sizeof (tc_t); break;
10272 case 6243: esalt_size = sizeof (tc_t); break;
10273 case 6600: esalt_size = sizeof (agilekey_t); break;
10274 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10275 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10276 case 7300: esalt_size = sizeof (rakp_t); break;
10277 case 7500: esalt_size = sizeof (krb5pa_t); break;
10278 case 8200: esalt_size = sizeof (cloudkey_t); break;
10279 case 8800: esalt_size = sizeof (androidfde_t); break;
10280 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10281 case 9400: esalt_size = sizeof (office2007_t); break;
10282 case 9500: esalt_size = sizeof (office2010_t); break;
10283 case 9600: esalt_size = sizeof (office2013_t); break;
10284 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10285 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10286 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10287 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10288 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10289 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10290 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10291 case 10200: esalt_size = sizeof (cram_md5_t); break;
10292 case 10400: esalt_size = sizeof (pdf_t); break;
10293 case 10410: esalt_size = sizeof (pdf_t); break;
10294 case 10420: esalt_size = sizeof (pdf_t); break;
10295 case 10500: esalt_size = sizeof (pdf_t); break;
10296 case 10600: esalt_size = sizeof (pdf_t); break;
10297 case 10700: esalt_size = sizeof (pdf_t); break;
10298 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10299 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10300 case 11400: esalt_size = sizeof (sip_t); break;
10301 case 11600: esalt_size = sizeof (seven_zip_t); break;
10302 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10303 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10304 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10305 case 13000: esalt_size = sizeof (rar5_t); break;
10306 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10307 }
10308
10309 data.esalt_size = esalt_size;
10310
10311 /**
10312 * choose dictionary parser
10313 */
10314
10315 if (hash_type == HASH_TYPE_LM)
10316 {
10317 get_next_word_func = get_next_word_lm;
10318 }
10319 else if (opts_type & OPTS_TYPE_PT_UPPER)
10320 {
10321 get_next_word_func = get_next_word_uc;
10322 }
10323 else
10324 {
10325 get_next_word_func = get_next_word_std;
10326 }
10327
10328 /**
10329 * dictstat
10330 */
10331
10332 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10333
10334 #ifdef _POSIX
10335 size_t dictstat_nmemb = 0;
10336 #endif
10337
10338 #ifdef _WIN
10339 uint dictstat_nmemb = 0;
10340 #endif
10341
10342 char dictstat[256] = { 0 };
10343
10344 FILE *dictstat_fp = NULL;
10345
10346 if (keyspace == 0)
10347 {
10348 snprintf (dictstat, sizeof (dictstat) - 1, "%s/hashcat.dictstat", profile_dir);
10349
10350 dictstat_fp = fopen (dictstat, "rb");
10351
10352 if (dictstat_fp)
10353 {
10354 #ifdef _POSIX
10355 struct stat tmpstat;
10356
10357 fstat (fileno (dictstat_fp), &tmpstat);
10358 #endif
10359
10360 #ifdef _WIN
10361 struct stat64 tmpstat;
10362
10363 _fstat64 (fileno (dictstat_fp), &tmpstat);
10364 #endif
10365
10366 if (tmpstat.st_mtime < COMPTIME)
10367 {
10368 /* with v0.15 the format changed so we have to ensure user is using a good version
10369 since there is no version-header in the dictstat file */
10370
10371 fclose (dictstat_fp);
10372
10373 unlink (dictstat);
10374 }
10375 else
10376 {
10377 while (!feof (dictstat_fp))
10378 {
10379 dictstat_t d;
10380
10381 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10382
10383 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10384
10385 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10386 {
10387 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10388
10389 return -1;
10390 }
10391 }
10392
10393 fclose (dictstat_fp);
10394 }
10395 }
10396 }
10397
10398 /**
10399 * potfile
10400 */
10401
10402 char potfile[256] = { 0 };
10403
10404 snprintf (potfile, sizeof (potfile) - 1, "%s/%s.pot", session_dir, session);
10405
10406 data.pot_fp = NULL;
10407
10408 FILE *out_fp = NULL;
10409 FILE *pot_fp = NULL;
10410
10411 if (show == 1 || left == 1)
10412 {
10413 pot_fp = fopen (potfile, "rb");
10414
10415 if (pot_fp == NULL)
10416 {
10417 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10418
10419 return (-1);
10420 }
10421
10422 if (outfile != NULL)
10423 {
10424 if ((out_fp = fopen (outfile, "ab")) == NULL)
10425 {
10426 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10427
10428 fclose (pot_fp);
10429
10430 return (-1);
10431 }
10432 }
10433 else
10434 {
10435 out_fp = stdout;
10436 }
10437 }
10438 else
10439 {
10440 if (potfile_disable == 0)
10441 {
10442 pot_fp = fopen (potfile, "ab");
10443
10444 if (pot_fp == NULL)
10445 {
10446 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10447
10448 return (-1);
10449 }
10450
10451 data.pot_fp = pot_fp;
10452 }
10453 }
10454
10455 pot_t *pot = NULL;
10456
10457 uint pot_cnt = 0;
10458 uint pot_avail = 0;
10459
10460 if (show == 1 || left == 1)
10461 {
10462 SUPPRESS_OUTPUT = 1;
10463
10464 pot_avail = count_lines (pot_fp);
10465
10466 rewind (pot_fp);
10467
10468 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10469
10470 uint pot_hashes_avail = 0;
10471
10472 uint line_num = 0;
10473
10474 while (!feof (pot_fp))
10475 {
10476 line_num++;
10477
10478 char line_buf[BUFSIZ] = { 0 };
10479
10480 int line_len = fgetl (pot_fp, line_buf);
10481
10482 if (line_len == 0) continue;
10483
10484 char *plain_buf = line_buf + line_len;
10485
10486 pot_t *pot_ptr = &pot[pot_cnt];
10487
10488 hash_t *hashes_buf = &pot_ptr->hash;
10489
10490 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10491 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10492
10493 if (pot_cnt == pot_hashes_avail)
10494 {
10495 uint pos = 0;
10496
10497 for (pos = 0; pos < INCR_POT; pos++)
10498 {
10499 if ((pot_cnt + pos) >= pot_avail) break;
10500
10501 pot_t *tmp_pot = &pot[pot_cnt + pos];
10502
10503 hash_t *tmp_hash = &tmp_pot->hash;
10504
10505 tmp_hash->digest = mymalloc (dgst_size);
10506
10507 if (isSalted)
10508 {
10509 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10510 }
10511
10512 if (esalt_size)
10513 {
10514 tmp_hash->esalt = mymalloc (esalt_size);
10515 }
10516
10517 pot_hashes_avail++;
10518 }
10519 }
10520
10521 int plain_len = 0;
10522
10523 int parser_status;
10524
10525 int iter = MAX_CUT_TRIES;
10526
10527 do
10528 {
10529 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10530 {
10531 if (line_buf[i] == ':')
10532 {
10533 line_len--;
10534
10535 break;
10536 }
10537 }
10538
10539 if (data.hash_mode != 2500)
10540 {
10541 parser_status = parse_func (line_buf, line_len, hashes_buf);
10542 }
10543 else
10544 {
10545 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10546
10547 if (line_len > max_salt_size)
10548 {
10549 parser_status = PARSER_GLOBAL_LENGTH;
10550 }
10551 else
10552 {
10553 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10554
10555 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10556
10557 hashes_buf->salt->salt_len = line_len;
10558
10559 parser_status = PARSER_OK;
10560 }
10561 }
10562
10563 // if NOT parsed without error, we add the ":" to the plain
10564
10565 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10566 {
10567 plain_len++;
10568 plain_buf--;
10569 }
10570
10571 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10572
10573 if (parser_status < PARSER_GLOBAL_ZERO)
10574 {
10575 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10576
10577 continue;
10578 }
10579
10580 if (plain_len >= 255) continue;
10581
10582 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10583
10584 pot_ptr->plain_len = plain_len;
10585
10586 pot_cnt++;
10587 }
10588
10589 fclose (pot_fp);
10590
10591 SUPPRESS_OUTPUT = 0;
10592
10593 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10594 }
10595
10596 /**
10597 * word len
10598 */
10599
10600 uint pw_min = PW_MIN;
10601 uint pw_max = PW_MAX;
10602
10603 switch (hash_mode)
10604 {
10605 case 400: if (pw_max > 40) pw_max = 40;
10606 break;
10607 case 500: if (pw_max > 16) pw_max = 16;
10608 break;
10609 case 1500: if (pw_max > 8) pw_max = 8;
10610 break;
10611 case 1600: if (pw_max > 16) pw_max = 16;
10612 break;
10613 case 1800: if (pw_max > 16) pw_max = 16;
10614 break;
10615 case 2100: if (pw_max > 16) pw_max = 16;
10616 break;
10617 case 2500: if (pw_min < 8) pw_min = 8;
10618 break;
10619 case 3000: if (pw_max > 7) pw_max = 7;
10620 break;
10621 case 5200: if (pw_max > 24) pw_max = 24;
10622 break;
10623 case 5800: if (pw_max > 16) pw_max = 16;
10624 break;
10625 case 6300: if (pw_max > 16) pw_max = 16;
10626 break;
10627 case 7400: if (pw_max > 16) pw_max = 16;
10628 break;
10629 case 7900: if (pw_max > 48) pw_max = 48;
10630 break;
10631 case 8500: if (pw_max > 8) pw_max = 8;
10632 break;
10633 case 8600: if (pw_max > 16) pw_max = 16;
10634 break;
10635 case 9710: pw_min = 5;
10636 pw_max = 5;
10637 break;
10638 case 9810: pw_min = 5;
10639 pw_max = 5;
10640 break;
10641 case 10410: pw_min = 5;
10642 pw_max = 5;
10643 break;
10644 case 10300: if (pw_max < 3) pw_min = 3;
10645 if (pw_max > 40) pw_max = 40;
10646 break;
10647 case 10500: if (pw_max < 3) pw_min = 3;
10648 if (pw_max > 40) pw_max = 40;
10649 break;
10650 case 10700: if (pw_max > 16) pw_max = 16;
10651 break;
10652 case 11300: if (pw_max > 40) pw_max = 40;
10653 break;
10654 case 12500: if (pw_max > 20) pw_max = 20;
10655 break;
10656 case 12800: if (pw_max > 24) pw_max = 24;
10657 break;
10658 }
10659
10660 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10661 {
10662 switch (attack_kern)
10663 {
10664 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10665 break;
10666 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10667 break;
10668 }
10669 }
10670
10671 /**
10672 * charsets : keep them together for more easy maintainnce
10673 */
10674
10675 cs_t mp_sys[6] = { { { 0 }, 0 } };
10676 cs_t mp_usr[4] = { { { 0 }, 0 } };
10677
10678 mp_setup_sys (mp_sys);
10679
10680 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10681 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10682 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10683 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10684
10685 /**
10686 * load hashes, part I: find input mode, count hashes
10687 */
10688
10689 uint hashlist_mode = 0;
10690 uint hashlist_format = HLFMT_HASHCAT;
10691
10692 uint hashes_avail = 0;
10693
10694 if (benchmark == 0)
10695 {
10696 struct stat f;
10697
10698 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10699
10700 if ((hash_mode == 2500) ||
10701 (hash_mode == 5200) ||
10702 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10703 (hash_mode == 9000))
10704 {
10705 hashlist_mode = HL_MODE_ARG;
10706
10707 char *hashfile = myargv[optind];
10708
10709 data.hashfile = hashfile;
10710
10711 logfile_top_var_string ("target", hashfile);
10712 }
10713
10714 if (hashlist_mode == HL_MODE_ARG)
10715 {
10716 if (hash_mode == 2500)
10717 {
10718 struct stat st;
10719
10720 if (stat (data.hashfile, &st) == -1)
10721 {
10722 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10723
10724 return (-1);
10725 }
10726
10727 hashes_avail = st.st_size / sizeof (hccap_t);
10728 }
10729 else
10730 {
10731 hashes_avail = 1;
10732 }
10733 }
10734 else if (hashlist_mode == HL_MODE_FILE)
10735 {
10736 char *hashfile = myargv[optind];
10737
10738 data.hashfile = hashfile;
10739
10740 logfile_top_var_string ("target", hashfile);
10741
10742 FILE *fp = NULL;
10743
10744 if ((fp = fopen (hashfile, "rb")) == NULL)
10745 {
10746 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10747
10748 return (-1);
10749 }
10750
10751 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10752
10753 hashes_avail = count_lines (fp);
10754
10755 rewind (fp);
10756
10757 if (hashes_avail == 0)
10758 {
10759 log_error ("ERROR: hashfile is empty or corrupt");
10760
10761 fclose (fp);
10762
10763 return (-1);
10764 }
10765
10766 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10767
10768 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10769 {
10770 log_error ("ERROR: remove not supported in native hashfile-format mode");
10771
10772 fclose (fp);
10773
10774 return (-1);
10775 }
10776
10777 fclose (fp);
10778 }
10779 }
10780 else
10781 {
10782 hashlist_mode = HL_MODE_ARG;
10783
10784 hashes_avail = 1;
10785 }
10786
10787 if (hash_mode == 3000) hashes_avail *= 2;
10788
10789 data.hashlist_mode = hashlist_mode;
10790 data.hashlist_format = hashlist_format;
10791
10792 logfile_top_uint (hashlist_mode);
10793 logfile_top_uint (hashlist_format);
10794
10795 /**
10796 * load hashes, part II: allocate required memory, set pointers
10797 */
10798
10799 hash_t *hashes_buf = NULL;
10800 void *digests_buf = NULL;
10801 salt_t *salts_buf = NULL;
10802 void *esalts_buf = NULL;
10803
10804 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10805
10806 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10807
10808 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10809 {
10810 u32 hash_pos;
10811
10812 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10813 {
10814 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10815
10816 hashes_buf[hash_pos].hash_info = hash_info;
10817
10818 if (username && (remove || show || left))
10819 {
10820 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10821 }
10822
10823 if (benchmark)
10824 {
10825 hash_info->orighash = (char *) mymalloc (256);
10826 }
10827 }
10828 }
10829
10830 if (isSalted)
10831 {
10832 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10833
10834 if (esalt_size)
10835 {
10836 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10837 }
10838 }
10839 else
10840 {
10841 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10842 }
10843
10844 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10845 {
10846 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10847
10848 if (isSalted)
10849 {
10850 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10851
10852 if (esalt_size)
10853 {
10854 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10855 }
10856 }
10857 else
10858 {
10859 hashes_buf[hash_pos].salt = &salts_buf[0];
10860 }
10861 }
10862
10863 /**
10864 * load hashes, part III: parse hashes or generate them if benchmark
10865 */
10866
10867 uint hashes_cnt = 0;
10868
10869 if (benchmark == 0)
10870 {
10871 if (keyspace == 1)
10872 {
10873 // useless to read hash file for keyspace, cheat a little bit w/ optind
10874 }
10875 else if (hashes_avail == 0)
10876 {
10877 }
10878 else if (hashlist_mode == HL_MODE_ARG)
10879 {
10880 char *input_buf = myargv[optind];
10881
10882 uint input_len = strlen (input_buf);
10883
10884 logfile_top_var_string ("target", input_buf);
10885
10886 char *hash_buf = NULL;
10887 int hash_len = 0;
10888
10889 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10890
10891 if (hash_len)
10892 {
10893 if (opts_type & OPTS_TYPE_HASH_COPY)
10894 {
10895 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10896
10897 hash_info_tmp->orighash = mystrdup (hash_buf);
10898 }
10899
10900 if (isSalted)
10901 {
10902 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
10903 }
10904
10905 int parser_status = PARSER_OK;
10906
10907 if (hash_mode == 2500)
10908 {
10909 if (hash_len == 0)
10910 {
10911 log_error ("ERROR: hccap file not specified");
10912
10913 return (-1);
10914 }
10915
10916 hashlist_mode = HL_MODE_FILE;
10917
10918 data.hashlist_mode = hashlist_mode;
10919
10920 FILE *fp = fopen (hash_buf, "rb");
10921
10922 if (fp == NULL)
10923 {
10924 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
10925
10926 return (-1);
10927 }
10928
10929 if (hashes_avail < 1)
10930 {
10931 log_error ("ERROR: hccap file is empty or corrupt");
10932
10933 fclose (fp);
10934
10935 return (-1);
10936 }
10937
10938 uint hccap_size = sizeof (hccap_t);
10939
10940 char *in = (char *) mymalloc (hccap_size);
10941
10942 while (!feof (fp))
10943 {
10944 int n = fread (in, hccap_size, 1, fp);
10945
10946 if (n != 1)
10947 {
10948 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
10949
10950 break;
10951 }
10952
10953 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
10954
10955 if (parser_status != PARSER_OK)
10956 {
10957 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
10958
10959 continue;
10960 }
10961
10962 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
10963
10964 if ((show == 1) || (left == 1))
10965 {
10966 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
10967
10968 char *salt_ptr = (char *) tmp_salt->salt_buf;
10969
10970 int cur_pos = tmp_salt->salt_len;
10971 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10972
10973 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
10974
10975 u8 *pke_ptr = (u8 *) wpa->pke;
10976
10977 // do the appending task
10978
10979 snprintf (salt_ptr + cur_pos,
10980 rem_len,
10981 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
10982 pke_ptr[20], pke_ptr[27], pke_ptr[26], pke_ptr[25], pke_ptr[24], pke_ptr[31], // MAC1
10983 pke_ptr[30], pke_ptr[29], pke_ptr[28], pke_ptr[35], pke_ptr[34], pke_ptr[33]); // MAC2
10984
10985
10986 // memset () the remaining part of the salt
10987
10988 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
10989 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10990
10991 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
10992
10993 tmp_salt->salt_len += 1 + 12 + 1 + 12;
10994 }
10995
10996 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);
10997 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);
10998
10999 hashes_cnt++;
11000 }
11001
11002 fclose (fp);
11003
11004 myfree (in);
11005 }
11006 else if (hash_mode == 3000)
11007 {
11008 if (hash_len == 32)
11009 {
11010 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11011
11012 hash_t *lm_hash_left = NULL;
11013
11014 if (parser_status == PARSER_OK)
11015 {
11016 lm_hash_left = &hashes_buf[hashes_cnt];
11017
11018 hashes_cnt++;
11019 }
11020 else
11021 {
11022 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11023 }
11024
11025 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11026
11027 hash_t *lm_hash_right = NULL;
11028
11029 if (parser_status == PARSER_OK)
11030 {
11031 lm_hash_right = &hashes_buf[hashes_cnt];
11032
11033 hashes_cnt++;
11034 }
11035 else
11036 {
11037 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11038 }
11039
11040 // show / left
11041
11042 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11043 {
11044 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);
11045 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);
11046 }
11047 }
11048 else
11049 {
11050 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11051
11052 if (parser_status == PARSER_OK)
11053 {
11054 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11055 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11056 }
11057
11058 if (parser_status == PARSER_OK)
11059 {
11060 hashes_cnt++;
11061 }
11062 else
11063 {
11064 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11065 }
11066 }
11067 }
11068 else
11069 {
11070 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11071
11072 if (parser_status == PARSER_OK)
11073 {
11074 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11075 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11076 }
11077
11078 if (parser_status == PARSER_OK)
11079 {
11080 hashes_cnt++;
11081 }
11082 else
11083 {
11084 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11085 }
11086 }
11087 }
11088 }
11089 else if (hashlist_mode == HL_MODE_FILE)
11090 {
11091 char *hashfile = data.hashfile;
11092
11093 FILE *fp;
11094
11095 if ((fp = fopen (hashfile, "rb")) == NULL)
11096 {
11097 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11098
11099 return (-1);
11100 }
11101
11102 uint line_num = 0;
11103
11104 while (!feof (fp))
11105 {
11106 line_num++;
11107
11108 char line_buf[BUFSIZ] = { 0 };
11109
11110 int line_len = fgetl (fp, line_buf);
11111
11112 if (line_len == 0) continue;
11113
11114 char *hash_buf = NULL;
11115 int hash_len = 0;
11116
11117 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11118
11119 if (username)
11120 {
11121 char *user_buf = NULL;
11122 int user_len = 0;
11123
11124 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11125
11126 if (remove || show)
11127 {
11128 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11129
11130 *user = (user_t *) mymalloc (sizeof (user_t));
11131
11132 user_t *user_ptr = *user;
11133
11134 if (user_buf != NULL)
11135 {
11136 user_ptr->user_name = mystrdup (user_buf);
11137 }
11138 else
11139 {
11140 user_ptr->user_name = mystrdup ("");
11141 }
11142
11143 user_ptr->user_len = user_len;
11144 }
11145 }
11146
11147 if (opts_type & OPTS_TYPE_HASH_COPY)
11148 {
11149 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11150
11151 hash_info_tmp->orighash = mystrdup (hash_buf);
11152 }
11153
11154 if (isSalted)
11155 {
11156 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11157 }
11158
11159 if (hash_mode == 3000)
11160 {
11161 if (hash_len == 32)
11162 {
11163 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11164
11165 if (parser_status < PARSER_GLOBAL_ZERO)
11166 {
11167 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11168
11169 continue;
11170 }
11171
11172 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11173
11174 hashes_cnt++;
11175
11176 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11177
11178 if (parser_status < PARSER_GLOBAL_ZERO)
11179 {
11180 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11181
11182 continue;
11183 }
11184
11185 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11186
11187 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);
11188
11189 hashes_cnt++;
11190
11191 // show / left
11192
11193 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);
11194 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);
11195 }
11196 else
11197 {
11198 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11199
11200 if (parser_status < PARSER_GLOBAL_ZERO)
11201 {
11202 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11203
11204 continue;
11205 }
11206
11207 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);
11208
11209 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11210 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11211
11212 hashes_cnt++;
11213 }
11214 }
11215 else
11216 {
11217 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11218
11219 if (parser_status < PARSER_GLOBAL_ZERO)
11220 {
11221 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11222
11223 continue;
11224 }
11225
11226 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);
11227
11228 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11229 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11230
11231 hashes_cnt++;
11232 }
11233 }
11234
11235 fclose (fp);
11236
11237 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11238
11239 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11240 }
11241 }
11242 else
11243 {
11244 if (isSalted)
11245 {
11246 hashes_buf[0].salt->salt_len = 8;
11247
11248 // special salt handling
11249
11250 switch (hash_mode)
11251 {
11252 case 1500: hashes_buf[0].salt->salt_len = 2;
11253 break;
11254 case 1731: hashes_buf[0].salt->salt_len = 4;
11255 break;
11256 case 2410: hashes_buf[0].salt->salt_len = 4;
11257 break;
11258 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11259 break;
11260 case 3100: hashes_buf[0].salt->salt_len = 1;
11261 break;
11262 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11263 break;
11264 case 5800: hashes_buf[0].salt->salt_len = 16;
11265 break;
11266 case 6800: hashes_buf[0].salt->salt_len = 32;
11267 break;
11268 case 8400: hashes_buf[0].salt->salt_len = 40;
11269 break;
11270 case 8800: hashes_buf[0].salt->salt_len = 16;
11271 break;
11272 case 8900: hashes_buf[0].salt->salt_len = 16;
11273 hashes_buf[0].salt->scrypt_N = 1024;
11274 hashes_buf[0].salt->scrypt_r = 1;
11275 hashes_buf[0].salt->scrypt_p = 1;
11276 break;
11277 case 9100: hashes_buf[0].salt->salt_len = 16;
11278 break;
11279 case 9300: hashes_buf[0].salt->salt_len = 14;
11280 hashes_buf[0].salt->scrypt_N = 16384;
11281 hashes_buf[0].salt->scrypt_r = 1;
11282 hashes_buf[0].salt->scrypt_p = 1;
11283 break;
11284 case 9400: hashes_buf[0].salt->salt_len = 16;
11285 break;
11286 case 9500: hashes_buf[0].salt->salt_len = 16;
11287 break;
11288 case 9600: hashes_buf[0].salt->salt_len = 16;
11289 break;
11290 case 9700: hashes_buf[0].salt->salt_len = 16;
11291 break;
11292 case 9710: hashes_buf[0].salt->salt_len = 16;
11293 break;
11294 case 9720: hashes_buf[0].salt->salt_len = 16;
11295 break;
11296 case 9800: hashes_buf[0].salt->salt_len = 16;
11297 break;
11298 case 9810: hashes_buf[0].salt->salt_len = 16;
11299 break;
11300 case 9820: hashes_buf[0].salt->salt_len = 16;
11301 break;
11302 case 10300: hashes_buf[0].salt->salt_len = 12;
11303 break;
11304 case 11500: hashes_buf[0].salt->salt_len = 4;
11305 break;
11306 case 11600: hashes_buf[0].salt->salt_len = 4;
11307 break;
11308 case 12400: hashes_buf[0].salt->salt_len = 4;
11309 break;
11310 case 12500: hashes_buf[0].salt->salt_len = 8;
11311 break;
11312 case 12600: hashes_buf[0].salt->salt_len = 64;
11313 break;
11314 }
11315
11316 // special esalt handling
11317
11318 switch (hash_mode)
11319 {
11320 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11321 break;
11322 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11323 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11324 break;
11325 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11326 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11327 break;
11328 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11329 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11330 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11331 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11332 break;
11333 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11334 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11335 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11336 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11337 break;
11338 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11339 break;
11340 case 10400: ((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 10410: ((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 10420: ((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 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11353 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11354 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11355 break;
11356 case 10600: ((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 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11361 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11362 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11363 break;
11364 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11365 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11366 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11367 break;
11368 }
11369 }
11370
11371 // set hashfile
11372
11373 switch (hash_mode)
11374 {
11375 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11376 break;
11377 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11378 break;
11379 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11380 break;
11381 case 6211: data.hashfile = mystrdup ("hashcat.tc");
11382 break;
11383 case 6212: data.hashfile = mystrdup ("hashcat.tc");
11384 break;
11385 case 6213: data.hashfile = mystrdup ("hashcat.tc");
11386 break;
11387 case 6221: data.hashfile = mystrdup ("hashcat.tc");
11388 break;
11389 case 6222: data.hashfile = mystrdup ("hashcat.tc");
11390 break;
11391 case 6223: data.hashfile = mystrdup ("hashcat.tc");
11392 break;
11393 case 6231: data.hashfile = mystrdup ("hashcat.tc");
11394 break;
11395 case 6232: data.hashfile = mystrdup ("hashcat.tc");
11396 break;
11397 case 6233: data.hashfile = mystrdup ("hashcat.tc");
11398 break;
11399 case 6241: data.hashfile = mystrdup ("hashcat.tc");
11400 break;
11401 case 6242: data.hashfile = mystrdup ("hashcat.tc");
11402 break;
11403 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11404 break;
11405 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11406 break;
11407 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11408 break;
11409 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11410 break;
11411 }
11412
11413 // set default iterations
11414
11415 switch (hash_mode)
11416 {
11417 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11418 break;
11419 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11420 break;
11421 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11422 break;
11423 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11424 break;
11425 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11426 break;
11427 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11428 break;
11429 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11430 break;
11431 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11432 break;
11433 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11434 break;
11435 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11436 break;
11437 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11438 break;
11439 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11440 break;
11441 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11442 break;
11443 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11444 break;
11445 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11446 break;
11447 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11448 break;
11449 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11450 break;
11451 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11452 break;
11453 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11454 break;
11455 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11456 break;
11457 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11458 break;
11459 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11460 break;
11461 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11462 break;
11463 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11464 break;
11465 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11466 break;
11467 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11468 break;
11469 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11470 break;
11471 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11472 break;
11473 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11474 break;
11475 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11476 break;
11477 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11478 break;
11479 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11480 break;
11481 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11482 break;
11483 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11484 break;
11485 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11486 break;
11487 case 8900: hashes_buf[0].salt->salt_iter = 1;
11488 break;
11489 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11490 break;
11491 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11492 break;
11493 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11494 break;
11495 case 9300: hashes_buf[0].salt->salt_iter = 1;
11496 break;
11497 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11498 break;
11499 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11500 break;
11501 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11502 break;
11503 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11504 break;
11505 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11506 break;
11507 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11508 break;
11509 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11510 break;
11511 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11512 break;
11513 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11514 break;
11515 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11516 break;
11517 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11518 break;
11519 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11520 break;
11521 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11522 break;
11523 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11524 break;
11525 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11526 break;
11527 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11528 break;
11529 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11530 break;
11531 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11532 break;
11533 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11534 break;
11535 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11536 break;
11537 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11538 break;
11539 }
11540
11541 hashes_cnt = 1;
11542 }
11543
11544 if (show == 1 || left == 1)
11545 {
11546 for (uint i = 0; i < pot_cnt; i++)
11547 {
11548 pot_t *pot_ptr = &pot[i];
11549
11550 hash_t *hashes_buf = &pot_ptr->hash;
11551
11552 local_free (hashes_buf->digest);
11553
11554 if (isSalted)
11555 {
11556 local_free (hashes_buf->salt);
11557 }
11558 }
11559
11560 local_free (pot);
11561
11562 if (data.quiet == 0) log_info_nn ("");
11563
11564 return (0);
11565 }
11566
11567 if (keyspace == 0)
11568 {
11569 if (hashes_cnt == 0)
11570 {
11571 log_error ("ERROR: No hashes loaded");
11572
11573 return (-1);
11574 }
11575 }
11576
11577 /**
11578 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11579 */
11580
11581 if (data.outfile != NULL)
11582 {
11583 if (data.hashfile != NULL)
11584 {
11585 #ifdef _POSIX
11586 struct stat tmpstat_outfile;
11587 struct stat tmpstat_hashfile;
11588 #endif
11589
11590 #ifdef _WIN
11591 struct stat64 tmpstat_outfile;
11592 struct stat64 tmpstat_hashfile;
11593 #endif
11594
11595 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11596
11597 if (tmp_outfile_fp)
11598 {
11599 #ifdef _POSIX
11600 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11601 #endif
11602
11603 #ifdef _WIN
11604 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11605 #endif
11606
11607 fclose (tmp_outfile_fp);
11608 }
11609
11610 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11611
11612 if (tmp_hashfile_fp)
11613 {
11614 #ifdef _POSIX
11615 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11616 #endif
11617
11618 #ifdef _WIN
11619 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11620 #endif
11621
11622 fclose (tmp_hashfile_fp);
11623 }
11624
11625 if (tmp_outfile_fp && tmp_outfile_fp)
11626 {
11627 tmpstat_outfile.st_mode = 0;
11628 tmpstat_outfile.st_nlink = 0;
11629 tmpstat_outfile.st_uid = 0;
11630 tmpstat_outfile.st_gid = 0;
11631 tmpstat_outfile.st_rdev = 0;
11632 tmpstat_outfile.st_atime = 0;
11633
11634 tmpstat_hashfile.st_mode = 0;
11635 tmpstat_hashfile.st_nlink = 0;
11636 tmpstat_hashfile.st_uid = 0;
11637 tmpstat_hashfile.st_gid = 0;
11638 tmpstat_hashfile.st_rdev = 0;
11639 tmpstat_hashfile.st_atime = 0;
11640
11641 #ifdef _POSIX
11642 tmpstat_outfile.st_blksize = 0;
11643 tmpstat_outfile.st_blocks = 0;
11644
11645 tmpstat_hashfile.st_blksize = 0;
11646 tmpstat_hashfile.st_blocks = 0;
11647 #endif
11648
11649 #ifdef _POSIX
11650 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11651 {
11652 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11653
11654 return (-1);
11655 }
11656 #endif
11657
11658 #ifdef _WIN
11659 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11660 {
11661 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11662
11663 return (-1);
11664 }
11665 #endif
11666 }
11667 }
11668 }
11669
11670 /**
11671 * Remove duplicates
11672 */
11673
11674 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11675
11676 if (isSalted)
11677 {
11678 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11679 }
11680 else
11681 {
11682 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11683 }
11684
11685 uint hashes_cnt_orig = hashes_cnt;
11686
11687 hashes_cnt = 1;
11688
11689 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11690 {
11691 if (isSalted)
11692 {
11693 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11694 {
11695 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11696 }
11697 }
11698 else
11699 {
11700 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11701 }
11702
11703 if (hashes_pos > hashes_cnt)
11704 {
11705 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11706 }
11707
11708 hashes_cnt++;
11709 }
11710
11711 /**
11712 * Potfile removes
11713 */
11714
11715 uint potfile_remove_cracks = 0;
11716
11717 if (potfile_disable == 0)
11718 {
11719 hash_t hash_buf;
11720
11721 hash_buf.digest = mymalloc (dgst_size);
11722 hash_buf.salt = NULL;
11723 hash_buf.esalt = NULL;
11724 hash_buf.hash_info = NULL;
11725 hash_buf.cracked = 0;
11726
11727 if (isSalted)
11728 {
11729 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11730 }
11731
11732 if (esalt_size)
11733 {
11734 hash_buf.esalt = mymalloc (esalt_size);
11735 }
11736
11737 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11738
11739 // no solution for these special hash types (for instane because they use hashfile in output etc)
11740 if ((hash_mode != 5200) &&
11741 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11742 (hash_mode != 9000))
11743 {
11744 FILE *fp = fopen (potfile, "rb");
11745
11746 if (fp != NULL)
11747 {
11748 while (!feof (fp))
11749 {
11750 char line_buf[BUFSIZ] = { 0 };
11751
11752 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
11753
11754 if (ptr == NULL) break;
11755
11756 int line_len = strlen (line_buf);
11757
11758 if (line_len == 0) continue;
11759
11760 int iter = MAX_CUT_TRIES;
11761
11762 for (int i = line_len - 1; i && iter; i--, line_len--)
11763 {
11764 if (line_buf[i] != ':') continue;
11765
11766 if (isSalted)
11767 {
11768 memset (hash_buf.salt, 0, sizeof (salt_t));
11769 }
11770
11771 hash_t *found = NULL;
11772
11773 if (hash_mode == 6800)
11774 {
11775 if (i < 64) // 64 = 16 * uint in salt_buf[]
11776 {
11777 // manipulate salt_buf
11778 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11779
11780 hash_buf.salt->salt_len = i;
11781
11782 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11783 }
11784 }
11785 else if (hash_mode == 2500)
11786 {
11787 if (i < 64) // 64 = 16 * uint in salt_buf[]
11788 {
11789 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11790 // manipulate salt_buf
11791
11792 // to be safe work with a copy (because of line_len loop, i etc)
11793
11794 char line_buf_cpy[BUFSIZ] = { 0 };
11795
11796 memcpy (line_buf_cpy, line_buf, i);
11797
11798 char *mac2_pos = strrchr (line_buf_cpy, ':');
11799
11800 if (mac2_pos == NULL) continue;
11801
11802 mac2_pos[0] = 0;
11803 mac2_pos++;
11804
11805 if (strlen (mac2_pos) != 12) continue;
11806
11807 char *mac1_pos = strrchr (line_buf_cpy, ':');
11808
11809 if (mac1_pos == NULL) continue;
11810
11811 mac1_pos[0] = 0;
11812 mac1_pos++;
11813
11814 if (strlen (mac1_pos) != 12) continue;
11815
11816 uint essid_length = mac1_pos - line_buf_cpy - 1;
11817
11818 // here we need the ESSID
11819 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11820
11821 hash_buf.salt->salt_len = essid_length;
11822
11823 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11824
11825 if (found)
11826 {
11827 wpa_t *wpa = (wpa_t *) found->esalt;
11828
11829 uint pke[25] = { 0 };
11830
11831 char *pke_ptr = (char *) pke;
11832
11833 for (uint i = 0; i < 25; i++)
11834 {
11835 pke[i] = byte_swap_32 (wpa->pke[i]);
11836 }
11837
11838 u8 mac1[6] = { 0 };
11839 u8 mac2[6] = { 0 };
11840
11841 memcpy (mac1, pke_ptr + 23, 6);
11842 memcpy (mac2, pke_ptr + 29, 6);
11843
11844 // compare hex string(s) vs binary MAC address(es)
11845
11846 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11847 {
11848 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
11849 {
11850 found = NULL;
11851 break;
11852 }
11853 }
11854
11855 // early skip ;)
11856 if (!found) continue;
11857
11858 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11859 {
11860 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
11861 {
11862 found = NULL;
11863 break;
11864 }
11865 }
11866 }
11867 }
11868 }
11869 else
11870 {
11871 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
11872
11873 if (parser_status == PARSER_OK)
11874 {
11875 if (isSalted)
11876 {
11877 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11878 }
11879 else
11880 {
11881 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11882 }
11883 }
11884 }
11885
11886 if (found == NULL) continue;
11887
11888 if (!found->cracked) potfile_remove_cracks++;
11889
11890 found->cracked = 1;
11891
11892 if (found) break;
11893
11894 iter--;
11895 }
11896 }
11897
11898 fclose (fp);
11899 }
11900 }
11901
11902 if (esalt_size)
11903 {
11904 local_free (hash_buf.esalt);
11905 }
11906
11907 if (isSalted)
11908 {
11909 local_free (hash_buf.salt);
11910 }
11911
11912 local_free (hash_buf.digest);
11913 }
11914
11915 /**
11916 * Now generate all the buffers required for later
11917 */
11918
11919 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
11920
11921 salt_t *salts_buf_new = NULL;
11922 void *esalts_buf_new = NULL;
11923
11924 if (isSalted)
11925 {
11926 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11927
11928 if (esalt_size)
11929 {
11930 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
11931 }
11932 }
11933 else
11934 {
11935 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
11936 }
11937
11938 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
11939
11940 uint digests_cnt = hashes_cnt;
11941 uint digests_done = 0;
11942
11943 uint size_digests = digests_cnt * dgst_size;
11944 uint size_shown = digests_cnt * sizeof (uint);
11945
11946 uint *digests_shown = (uint *) mymalloc (size_shown);
11947 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
11948
11949 uint salts_cnt = 0;
11950 uint salts_done = 0;
11951
11952 hashinfo_t **hash_info = NULL;
11953
11954 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11955 {
11956 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
11957
11958 if (username && (remove || show))
11959 {
11960 uint user_pos;
11961
11962 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
11963 {
11964 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
11965
11966 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
11967 }
11968 }
11969 }
11970
11971 uint *salts_shown = (uint *) mymalloc (size_shown);
11972
11973 salt_t *salt_buf;
11974
11975 {
11976 // copied from inner loop
11977
11978 salt_buf = &salts_buf_new[salts_cnt];
11979
11980 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
11981
11982 if (esalt_size)
11983 {
11984 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
11985 }
11986
11987 salt_buf->digests_cnt = 0;
11988 salt_buf->digests_done = 0;
11989 salt_buf->digests_offset = 0;
11990
11991 salts_cnt++;
11992 }
11993
11994 if (hashes_buf[0].cracked == 1)
11995 {
11996 digests_shown[0] = 1;
11997
11998 digests_done++;
11999
12000 salt_buf->digests_done++;
12001 }
12002
12003 salt_buf->digests_cnt++;
12004
12005 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12006
12007 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12008 {
12009 hash_info[0] = hashes_buf[0].hash_info;
12010 }
12011
12012 // copy from inner loop
12013
12014 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12015 {
12016 if (isSalted)
12017 {
12018 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12019 {
12020 salt_buf = &salts_buf_new[salts_cnt];
12021
12022 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12023
12024 if (esalt_size)
12025 {
12026 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12027 }
12028
12029 salt_buf->digests_cnt = 0;
12030 salt_buf->digests_done = 0;
12031 salt_buf->digests_offset = hashes_pos;
12032
12033 salts_cnt++;
12034 }
12035 }
12036
12037 if (hashes_buf[hashes_pos].cracked == 1)
12038 {
12039 digests_shown[hashes_pos] = 1;
12040
12041 digests_done++;
12042
12043 salt_buf->digests_done++;
12044 }
12045
12046 salt_buf->digests_cnt++;
12047
12048 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12049
12050 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12051 {
12052 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12053 }
12054 }
12055
12056 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12057 {
12058 salt_t *salt_buf = &salts_buf_new[salt_pos];
12059
12060 if (salt_buf->digests_done == salt_buf->digests_cnt)
12061 {
12062 salts_shown[salt_pos] = 1;
12063
12064 salts_done++;
12065 }
12066
12067 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12068 }
12069
12070 local_free (digests_buf);
12071 local_free (salts_buf);
12072 local_free (esalts_buf);
12073
12074 digests_buf = digests_buf_new;
12075 salts_buf = salts_buf_new;
12076 esalts_buf = esalts_buf_new;
12077
12078 local_free (hashes_buf);
12079
12080 /**
12081 * special modification not set from parser
12082 */
12083
12084 switch (hash_mode)
12085 {
12086 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12087 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12088 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12089 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12090 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12091 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12092 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12093 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12094 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12095 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12096 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12097 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12098 }
12099
12100 if (truecrypt_keyfiles)
12101 {
12102 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12103
12104 char *keyfiles = strdup (truecrypt_keyfiles);
12105
12106 char *keyfile = strtok (keyfiles, ",");
12107
12108 do
12109 {
12110 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12111
12112 } while ((keyfile = strtok (NULL, ",")) != NULL);
12113
12114 free (keyfiles);
12115 }
12116
12117 data.digests_cnt = digests_cnt;
12118 data.digests_done = digests_done;
12119 data.digests_buf = digests_buf;
12120 data.digests_shown = digests_shown;
12121 data.digests_shown_tmp = digests_shown_tmp;
12122
12123 data.salts_cnt = salts_cnt;
12124 data.salts_done = salts_done;
12125 data.salts_buf = salts_buf;
12126 data.salts_shown = salts_shown;
12127
12128 data.esalts_buf = esalts_buf;
12129 data.hash_info = hash_info;
12130
12131 /**
12132 * Automatic Optimizers
12133 */
12134
12135 if (salts_cnt == 1)
12136 opti_type |= OPTI_TYPE_SINGLE_SALT;
12137
12138 if (digests_cnt == 1)
12139 opti_type |= OPTI_TYPE_SINGLE_HASH;
12140
12141 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12142 opti_type |= OPTI_TYPE_NOT_ITERATED;
12143
12144 if (attack_mode == ATTACK_MODE_BF)
12145 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12146
12147 data.opti_type = opti_type;
12148
12149 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12150 {
12151 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12152 {
12153 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12154 {
12155 if (opts_type & OPTS_TYPE_ST_ADD80)
12156 {
12157 opts_type &= ~OPTS_TYPE_ST_ADD80;
12158 opts_type |= OPTS_TYPE_PT_ADD80;
12159 }
12160
12161 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12162 {
12163 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12164 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12165 }
12166
12167 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12168 {
12169 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12170 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12171 }
12172 }
12173 }
12174 }
12175
12176 /**
12177 * Some algorithm, like descrypt, can benefit from JIT compilation
12178 */
12179
12180 int force_jit_compilation = -1;
12181
12182 if (hash_mode == 8900)
12183 {
12184 force_jit_compilation = 8900;
12185 }
12186 else if (hash_mode == 9300)
12187 {
12188 force_jit_compilation = 8900;
12189 }
12190 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12191 {
12192 force_jit_compilation = 1500;
12193 }
12194
12195 /**
12196 * generate bitmap tables
12197 */
12198
12199 const uint bitmap_shift1 = 5;
12200 const uint bitmap_shift2 = 13;
12201
12202 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12203
12204 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12205 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12206 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12207 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12208 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12209 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12210 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12211 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12212
12213 uint bitmap_bits;
12214 uint bitmap_nums;
12215 uint bitmap_mask;
12216 uint bitmap_size;
12217
12218 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12219 {
12220 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12221
12222 bitmap_nums = 1 << bitmap_bits;
12223
12224 bitmap_mask = bitmap_nums - 1;
12225
12226 bitmap_size = bitmap_nums * sizeof (uint);
12227
12228 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12229
12230 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;
12231 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;
12232
12233 break;
12234 }
12235
12236 bitmap_nums = 1 << bitmap_bits;
12237
12238 bitmap_mask = bitmap_nums - 1;
12239
12240 bitmap_size = bitmap_nums * sizeof (uint);
12241
12242 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);
12243 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);
12244
12245 /**
12246 * prepare quick rule
12247 */
12248
12249 data.rule_buf_l = rule_buf_l;
12250 data.rule_buf_r = rule_buf_r;
12251
12252 int rule_len_l = (int) strlen (rule_buf_l);
12253 int rule_len_r = (int) strlen (rule_buf_r);
12254
12255 data.rule_len_l = rule_len_l;
12256 data.rule_len_r = rule_len_r;
12257
12258 /**
12259 * load rules
12260 */
12261
12262 uint *all_kernel_rules_cnt = NULL;
12263
12264 kernel_rule_t **all_kernel_rules_buf = NULL;
12265
12266 if (rp_files_cnt)
12267 {
12268 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12269
12270 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12271 }
12272
12273 char rule_buf[BUFSIZ] = { 0 };
12274
12275 int rule_len = 0;
12276
12277 for (uint i = 0; i < rp_files_cnt; i++)
12278 {
12279 uint kernel_rules_avail = 0;
12280
12281 uint kernel_rules_cnt = 0;
12282
12283 kernel_rule_t *kernel_rules_buf = NULL;
12284
12285 char *rp_file = rp_files[i];
12286
12287 char in[BLOCK_SIZE] = { 0 };
12288 char out[BLOCK_SIZE] = { 0 };
12289
12290 FILE *fp = NULL;
12291
12292 uint rule_line = 0;
12293
12294 if ((fp = fopen (rp_file, "rb")) == NULL)
12295 {
12296 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12297
12298 return (-1);
12299 }
12300
12301 while (!feof (fp))
12302 {
12303 memset (rule_buf, 0, BUFSIZ);
12304
12305 rule_len = fgetl (fp, rule_buf);
12306
12307 rule_line++;
12308
12309 if (rule_len == 0) continue;
12310
12311 if (rule_buf[0] == '#') continue;
12312
12313 if (kernel_rules_avail == kernel_rules_cnt)
12314 {
12315 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12316
12317 kernel_rules_avail += INCR_RULES;
12318 }
12319
12320 memset (in, 0, BLOCK_SIZE);
12321 memset (out, 0, BLOCK_SIZE);
12322
12323 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12324
12325 if (result == -1)
12326 {
12327 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12328
12329 continue;
12330 }
12331
12332 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12333 {
12334 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12335
12336 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12337
12338 continue;
12339 }
12340
12341 /* its so slow
12342 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12343 {
12344 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12345
12346 continue;
12347 }
12348 */
12349
12350 kernel_rules_cnt++;
12351 }
12352
12353 fclose (fp);
12354
12355 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12356
12357 all_kernel_rules_buf[i] = kernel_rules_buf;
12358 }
12359
12360 /**
12361 * merge rules or automatic rule generator
12362 */
12363
12364 uint kernel_rules_cnt = 0;
12365
12366 kernel_rule_t *kernel_rules_buf = NULL;
12367
12368 if (attack_mode == ATTACK_MODE_STRAIGHT)
12369 {
12370 if (rp_files_cnt)
12371 {
12372 kernel_rules_cnt = 1;
12373
12374 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12375
12376 repeats[0] = kernel_rules_cnt;
12377
12378 for (uint i = 0; i < rp_files_cnt; i++)
12379 {
12380 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12381
12382 repeats[i + 1] = kernel_rules_cnt;
12383 }
12384
12385 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12386
12387 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12388
12389 for (uint i = 0; i < kernel_rules_cnt; i++)
12390 {
12391 uint out_pos = 0;
12392
12393 kernel_rule_t *out = &kernel_rules_buf[i];
12394
12395 for (uint j = 0; j < rp_files_cnt; j++)
12396 {
12397 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12398 uint in_pos;
12399
12400 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12401
12402 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12403 {
12404 if (out_pos == RULES_MAX - 1)
12405 {
12406 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12407
12408 break;
12409 }
12410
12411 out->cmds[out_pos] = in->cmds[in_pos];
12412 }
12413 }
12414 }
12415
12416 local_free (repeats);
12417 }
12418 else if (rp_gen)
12419 {
12420 uint kernel_rules_avail = 0;
12421
12422 while (kernel_rules_cnt < rp_gen)
12423 {
12424 if (kernel_rules_avail == kernel_rules_cnt)
12425 {
12426 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12427
12428 kernel_rules_avail += INCR_RULES;
12429 }
12430
12431 memset (rule_buf, 0, BLOCK_SIZE);
12432
12433 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12434
12435 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12436
12437 kernel_rules_cnt++;
12438 }
12439 }
12440 }
12441
12442 /**
12443 * generate NOP rules
12444 */
12445
12446 if (kernel_rules_cnt == 0)
12447 {
12448 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12449
12450 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12451
12452 kernel_rules_cnt++;
12453 }
12454
12455 data.kernel_rules_cnt = kernel_rules_cnt;
12456 data.kernel_rules_buf = kernel_rules_buf;
12457
12458 /**
12459 * OpenCL platforms: detect
12460 */
12461
12462 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
12463 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
12464
12465 cl_uint platforms_cnt = 0;
12466 cl_uint platform_devices_cnt = 0;
12467
12468 if (keyspace == 0)
12469 {
12470 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12471
12472 if (platforms_cnt == 0)
12473 {
12474 log_error ("ERROR: No OpenCL compatible platform found");
12475
12476 return (-1);
12477 }
12478 }
12479
12480 /**
12481 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12482 */
12483
12484 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12485 {
12486 cl_platform_id platform = platforms[platform_id];
12487
12488 char platform_vendor[INFOSZ] = { 0 };
12489
12490 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12491
12492 #ifdef HAVE_HWMON
12493 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12494 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12495 {
12496 // make sure that we do not directly control the fan for NVidia
12497
12498 gpu_temp_retain = 0;
12499
12500 data.gpu_temp_retain = gpu_temp_retain;
12501 }
12502 #endif // HAVE_NVML || HAVE_NVAPI
12503 #endif
12504 }
12505
12506 /**
12507 * OpenCL devices: simply push all devices from all platforms into the same device array
12508 */
12509
12510 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12511
12512 data.devices_param = devices_param;
12513
12514 uint devices_cnt = 0;
12515
12516 uint devices_active = 0;
12517
12518 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12519 {
12520 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12521
12522 cl_platform_id platform = platforms[platform_id];
12523
12524 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12525
12526 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12527 {
12528 size_t param_value_size = 0;
12529
12530 const uint device_id = devices_cnt;
12531
12532 hc_device_param_t *device_param = &data.devices_param[device_id];
12533
12534 device_param->device = platform_devices[platform_devices_id];
12535
12536 device_param->device_id = device_id;
12537
12538 device_param->platform_devices_id = platform_devices_id;
12539
12540 // device_type
12541
12542 cl_device_type device_type;
12543
12544 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12545
12546 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12547
12548 device_param->device_type = device_type;
12549
12550 // vendor_id
12551
12552 cl_uint vendor_id = 0;
12553
12554 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR_ID, sizeof (vendor_id), &vendor_id, NULL);
12555
12556 device_param->vendor_id = vendor_id;
12557
12558 // device_name
12559
12560 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
12561
12562 char *device_name = (char *) mymalloc (param_value_size);
12563
12564 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
12565
12566 device_param->device_name = device_name;
12567
12568 // tuning db
12569
12570 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
12571
12572 // device_version
12573
12574 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
12575
12576 char *device_version = (char *) mymalloc (param_value_size);
12577
12578 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
12579
12580 device_param->device_version = device_version;
12581
12582 // device_opencl_version
12583
12584 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
12585
12586 char *device_opencl_version = (char *) mymalloc (param_value_size);
12587
12588 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
12589
12590 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
12591
12592 myfree (device_opencl_version);
12593
12594 if (strstr (device_version, "pocl"))
12595 {
12596 // pocl returns the real vendor_id in CL_DEVICE_VENDOR_ID which causes many problems because of hms and missing amd_bfe () etc
12597 // we need to overwrite vendor_id to avoid this. maybe open pocl issue?
12598
12599 cl_uint vendor_id = VENDOR_ID_GENERIC;
12600
12601 device_param->vendor_id = vendor_id;
12602 }
12603
12604 // vector_width
12605
12606 cl_uint vector_width;
12607
12608 if (opencl_vector_width_chgd == 0)
12609 {
12610 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
12611 {
12612 if (opti_type & OPTI_TYPE_USES_BITS_64)
12613 {
12614 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
12615 }
12616 else
12617 {
12618 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12619 }
12620 }
12621 else
12622 {
12623 vector_width = (cl_uint) tuningdb_entry->vector_width;
12624 }
12625 }
12626 else
12627 {
12628 vector_width = opencl_vector_width;
12629 }
12630
12631 if (vector_width > 16) vector_width = 16;
12632
12633 device_param->vector_width = vector_width;
12634
12635 // max_compute_units
12636
12637 cl_uint device_processors;
12638
12639 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12640
12641 device_param->device_processors = device_processors;
12642
12643 // max_mem_alloc_size
12644
12645 cl_ulong device_maxmem_alloc;
12646
12647 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12648
12649 device_param->device_maxmem_alloc = device_maxmem_alloc;
12650
12651 // max_mem_alloc_size
12652
12653 cl_ulong device_global_mem;
12654
12655 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12656
12657 device_param->device_global_mem = device_global_mem;
12658
12659 // max_clock_frequency
12660
12661 cl_uint device_maxclock_frequency;
12662
12663 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12664
12665 device_param->device_maxclock_frequency = device_maxclock_frequency;
12666
12667 // skipped
12668
12669 const u32 skipped1 = ((devices_filter & (1 << device_id)) == 0);
12670 const u32 skipped2 = ((device_types_filter & (device_type)) == 0);
12671
12672 device_param->skipped = (skipped1 || skipped2);
12673
12674 // driver_version
12675 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
12676
12677 char *driver_version = (char *) mymalloc (param_value_size);
12678
12679 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
12680
12681 device_param->driver_version = driver_version;
12682
12683 // device_name_chksum
12684
12685 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12686
12687 #if __x86_64__
12688 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);
12689 #else
12690 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);
12691 #endif
12692
12693 uint device_name_digest[4] = { 0 };
12694
12695 md5_64 ((uint *) device_name_chksum, device_name_digest);
12696
12697 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
12698
12699 device_param->device_name_chksum = device_name_chksum;
12700
12701 // device_processor_cores
12702
12703 if (device_type & CL_DEVICE_TYPE_CPU)
12704 {
12705 cl_uint device_processor_cores = 1;
12706
12707 device_param->device_processor_cores = device_processor_cores;
12708 }
12709
12710 if (device_type & CL_DEVICE_TYPE_GPU)
12711 {
12712 if (vendor_id == VENDOR_ID_AMD)
12713 {
12714 cl_uint device_processor_cores = 0;
12715
12716 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12717
12718 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12719
12720 device_param->device_processor_cores = device_processor_cores;
12721 }
12722 else if (vendor_id == VENDOR_ID_NV)
12723 {
12724 cl_uint kernel_exec_timeout = 0;
12725
12726 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12727
12728 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12729
12730 device_param->kernel_exec_timeout = kernel_exec_timeout;
12731
12732 cl_uint device_processor_cores = 0;
12733
12734 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12735
12736 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12737
12738 device_param->device_processor_cores = device_processor_cores;
12739
12740 cl_uint sm_minor = 0;
12741 cl_uint sm_major = 0;
12742
12743 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12744 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12745
12746 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12747 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12748
12749 device_param->sm_minor = sm_minor;
12750 device_param->sm_major = sm_major;
12751 }
12752 else
12753 {
12754 cl_uint device_processor_cores = 1;
12755
12756 device_param->device_processor_cores = device_processor_cores;
12757 }
12758 }
12759
12760 // display results
12761
12762 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12763 {
12764 if (device_param->skipped == 0)
12765 {
12766 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12767 device_id + 1,
12768 device_name,
12769 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
12770 (unsigned int) (device_global_mem / 1024 / 1024),
12771 (unsigned int) (device_maxclock_frequency),
12772 (unsigned int) device_processors);
12773 }
12774 else
12775 {
12776 log_info ("Device #%u: %s, skipped",
12777 device_id + 1,
12778 device_name);
12779 }
12780 }
12781
12782 // common driver check
12783
12784 if (device_param->skipped == 0)
12785 {
12786 if (strstr (device_version, "pocl"))
12787 {
12788 if (force == 0)
12789 {
12790 log_info ("");
12791 log_info ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
12792 log_info ("You are STRONGLY encouraged not to use it");
12793 log_info ("You can use --force to override this but do not post error reports if you do so");
12794 log_info ("");
12795
12796 return (-1);
12797 }
12798 }
12799
12800 if (device_type & CL_DEVICE_TYPE_GPU)
12801 {
12802 if (vendor_id == VENDOR_ID_NV)
12803 {
12804 if (device_param->kernel_exec_timeout != 0)
12805 {
12806 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);
12807 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12808 }
12809 }
12810 else if (vendor_id == VENDOR_ID_AMD)
12811 {
12812 int catalyst_check = (force == 1) ? 0 : 1;
12813
12814 int catalyst_warn = 0;
12815
12816 int catalyst_broken = 0;
12817
12818 if (catalyst_check == 1)
12819 {
12820 catalyst_warn = 1;
12821
12822 // v14.9 and higher
12823 if (atoi (device_param->driver_version) >= 1573)
12824 {
12825 catalyst_warn = 0;
12826 }
12827
12828 catalyst_check = 0;
12829 }
12830
12831 if (catalyst_broken == 1)
12832 {
12833 log_info ("");
12834 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
12835 log_info ("It will pass over cracked hashes and does not report them as cracked");
12836 log_info ("You are STRONGLY encouraged not to use it");
12837 log_info ("You can use --force to override this but do not post error reports if you do so");
12838 log_info ("");
12839
12840 return (-1);
12841 }
12842
12843 if (catalyst_warn == 1)
12844 {
12845 log_info ("");
12846 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
12847 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
12848 log_info ("See oclHashcat's homepage for official supported catalyst drivers");
12849 #ifdef _WIN
12850 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
12851 #endif
12852 log_info ("You can use --force to override this but do not post error reports if you do so");
12853 log_info ("");
12854
12855 return (-1);
12856 }
12857 }
12858 }
12859
12860 /**
12861 * kernel accel and loops tuning db adjustment
12862 */
12863
12864 device_param->kernel_accel_min = 1;
12865 device_param->kernel_accel_max = 1024;
12866
12867 device_param->kernel_loops_min = 1;
12868 device_param->kernel_loops_max = 1024;
12869
12870 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
12871
12872 if (tuningdb_entry)
12873 {
12874 u32 _kernel_accel = tuningdb_entry->kernel_accel;
12875 u32 _kernel_loops = tuningdb_entry->kernel_loops;
12876
12877 if (_kernel_accel)
12878 {
12879 device_param->kernel_accel_min = _kernel_accel;
12880 device_param->kernel_accel_max = _kernel_accel;
12881 }
12882
12883 if (_kernel_loops)
12884 {
12885 if (workload_profile == 1)
12886 {
12887 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
12888 }
12889 else if (workload_profile == 2)
12890 {
12891 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
12892 }
12893
12894 device_param->kernel_loops_min = _kernel_loops;
12895 device_param->kernel_loops_max = _kernel_loops;
12896 }
12897 }
12898
12899 // commandline parameters overwrite tuningdb entries
12900
12901 if (kernel_accel)
12902 {
12903 device_param->kernel_accel_min = kernel_accel;
12904 device_param->kernel_accel_max = kernel_accel;
12905 }
12906
12907 if (kernel_loops)
12908 {
12909 device_param->kernel_loops_min = kernel_loops;
12910 device_param->kernel_loops_max = kernel_loops;
12911 }
12912
12913 /**
12914 * activate device
12915 */
12916
12917 devices_active++;
12918 }
12919
12920 // next please
12921
12922 devices_cnt++;
12923 }
12924 }
12925
12926 if (keyspace == 0 && devices_active == 0)
12927 {
12928 log_error ("ERROR: No devices found/left");
12929
12930 return (-1);
12931 }
12932
12933 data.devices_cnt = devices_cnt;
12934
12935 data.devices_active = devices_active;
12936
12937 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12938 {
12939 log_info ("");
12940 }
12941
12942 /**
12943 * HM devices: init
12944 */
12945
12946 #ifdef HAVE_HWMON
12947 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12948 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
12949 #endif
12950
12951 #ifdef HAVE_ADL
12952 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
12953 #endif
12954
12955 if (gpu_temp_disable == 0)
12956 {
12957 #if defined(WIN) && defined(HAVE_NVAPI)
12958 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
12959
12960 if (nvapi_init (nvapi) == 0)
12961 data.hm_nv = nvapi;
12962
12963 if (data.hm_nv)
12964 {
12965 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
12966 {
12967 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
12968
12969 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12970
12971 int tmp_out = 0;
12972
12973 for (int i = 0; i < tmp_in; i++)
12974 {
12975 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
12976 }
12977
12978 for (int i = 0; i < tmp_out; i++)
12979 {
12980 NV_GPU_COOLER_SETTINGS pCoolerSettings;
12981
12982 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
12983
12984 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;
12985 }
12986 }
12987 }
12988 #endif // WIN && HAVE_NVAPI
12989
12990 #if defined(LINUX) && defined(HAVE_NVML)
12991 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
12992
12993 if (nvml_init (nvml) == 0)
12994 data.hm_nv = nvml;
12995
12996 if (data.hm_nv)
12997 {
12998 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
12999 {
13000 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13001
13002 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13003
13004 int tmp_out = 0;
13005
13006 for (int i = 0; i < tmp_in; i++)
13007 {
13008 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13009 }
13010
13011 for (int i = 0; i < tmp_out; i++)
13012 {
13013 unsigned int speed;
13014
13015 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;
13016 }
13017 }
13018 }
13019 #endif // LINUX && HAVE_NVML
13020
13021 data.hm_amd = NULL;
13022
13023 #ifdef HAVE_ADL
13024 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13025
13026 if (adl_init (adl) == 0)
13027 data.hm_amd = adl;
13028
13029 if (data.hm_amd)
13030 {
13031 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13032 {
13033 // total number of adapters
13034
13035 int hm_adapters_num;
13036
13037 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13038
13039 // adapter info
13040
13041 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13042
13043 if (lpAdapterInfo == NULL) return (-1);
13044
13045 // get a list (of ids of) valid/usable adapters
13046
13047 int num_adl_adapters = 0;
13048
13049 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13050
13051 if (num_adl_adapters > 0)
13052 {
13053 hc_thread_mutex_lock (mux_adl);
13054
13055 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13056
13057 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13058
13059 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13060 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13061
13062 hc_thread_mutex_unlock (mux_adl);
13063 }
13064
13065 myfree (valid_adl_device_list);
13066 myfree (lpAdapterInfo);
13067 }
13068 }
13069 #endif // HAVE_ADL
13070
13071 if (data.hm_amd == NULL && data.hm_nv == NULL)
13072 {
13073 gpu_temp_disable = 1;
13074 }
13075 }
13076
13077 /**
13078 * OpenCL devices: allocate buffer for device specific information
13079 */
13080
13081 #ifdef HAVE_HWMON
13082 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13083
13084 #ifdef HAVE_ADL
13085 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13086
13087 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13088 #endif // ADL
13089 #endif
13090
13091 /**
13092 * enable custom signal handler(s)
13093 */
13094
13095 if (benchmark == 0)
13096 {
13097 hc_signal (sigHandler_default);
13098 }
13099 else
13100 {
13101 hc_signal (sigHandler_benchmark);
13102 }
13103
13104 /**
13105 * User-defined GPU temp handling
13106 */
13107
13108 #ifdef HAVE_HWMON
13109 if (gpu_temp_disable == 1)
13110 {
13111 gpu_temp_abort = 0;
13112 gpu_temp_retain = 0;
13113 }
13114
13115 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13116 {
13117 if (gpu_temp_abort < gpu_temp_retain)
13118 {
13119 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13120
13121 return (-1);
13122 }
13123 }
13124
13125 data.gpu_temp_disable = gpu_temp_disable;
13126 data.gpu_temp_abort = gpu_temp_abort;
13127 data.gpu_temp_retain = gpu_temp_retain;
13128 #endif
13129
13130 /**
13131 * inform the user
13132 */
13133
13134 if (data.quiet == 0)
13135 {
13136 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13137
13138 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);
13139
13140 if (attack_mode == ATTACK_MODE_STRAIGHT)
13141 {
13142 log_info ("Rules: %u", kernel_rules_cnt);
13143 }
13144
13145 if (opti_type)
13146 {
13147 log_info ("Applicable Optimizers:");
13148
13149 for (uint i = 0; i < 32; i++)
13150 {
13151 const uint opti_bit = 1u << i;
13152
13153 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13154 }
13155 }
13156
13157 /**
13158 * Watchdog and Temperature balance
13159 */
13160
13161 #ifdef HAVE_HWMON
13162 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13163 {
13164 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13165 }
13166
13167 if (gpu_temp_abort == 0)
13168 {
13169 log_info ("Watchdog: Temperature abort trigger disabled");
13170 }
13171 else
13172 {
13173 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13174 }
13175
13176 if (gpu_temp_retain == 0)
13177 {
13178 log_info ("Watchdog: Temperature retain trigger disabled");
13179 }
13180 else
13181 {
13182 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13183 }
13184 #endif
13185 }
13186
13187 if (data.quiet == 0) log_info ("");
13188
13189 /**
13190 * HM devices: copy
13191 */
13192
13193 if (gpu_temp_disable == 0)
13194 {
13195 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13196 {
13197 hc_device_param_t *device_param = &data.devices_param[device_id];
13198
13199 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13200
13201 if (device_param->skipped) continue;
13202
13203 const uint platform_devices_id = device_param->platform_devices_id;
13204
13205 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13206 if (device_param->vendor_id == VENDOR_ID_NV)
13207 {
13208 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13209 }
13210 #endif
13211
13212 #ifdef HAVE_ADL
13213 if (device_param->vendor_id == VENDOR_ID_AMD)
13214 {
13215 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13216 }
13217 #endif
13218 }
13219 }
13220
13221 /*
13222 * Temporary fix:
13223 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13224 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13225 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13226 * Driver / ADL bug?
13227 */
13228
13229 #ifdef HAVE_ADL
13230 if (powertune_enable == 1)
13231 {
13232 hc_thread_mutex_lock (mux_adl);
13233
13234 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13235 {
13236 hc_device_param_t *device_param = &data.devices_param[device_id];
13237
13238 if (device_param->skipped) continue;
13239
13240 if (data.hm_device[device_id].od_version == 6)
13241 {
13242 // set powertune value only
13243
13244 int powertune_supported = 0;
13245
13246 int ADL_rc = 0;
13247
13248 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13249 {
13250 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13251
13252 return (-1);
13253 }
13254
13255 if (powertune_supported != 0)
13256 {
13257 // powertune set
13258 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13259
13260 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13261 {
13262 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13263
13264 return (-1);
13265 }
13266
13267 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13268 {
13269 log_error ("ERROR: Failed to set new ADL PowerControl values");
13270
13271 return (-1);
13272 }
13273 }
13274 }
13275 }
13276
13277 hc_thread_mutex_unlock (mux_adl);
13278 }
13279 #endif // HAVE_ADK
13280 #endif // HAVE_HWMON
13281
13282 #ifdef DEBUG
13283 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
13284 #endif
13285
13286 uint kernel_power_all = 0;
13287
13288 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13289 {
13290 /**
13291 * host buffer
13292 */
13293
13294 hc_device_param_t *device_param = &data.devices_param[device_id];
13295
13296 if (device_param->skipped) continue;
13297
13298 /**
13299 * device properties
13300 */
13301
13302 const char *device_name_chksum = device_param->device_name_chksum;
13303 const u32 device_processors = device_param->device_processors;
13304 const u32 device_processor_cores = device_param->device_processor_cores;
13305
13306 /**
13307 * create context for each device
13308 */
13309
13310 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
13311
13312 /**
13313 * create command-queue
13314 */
13315
13316 // not supported with NV
13317 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13318
13319 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
13320
13321 /**
13322 * create input buffers on device : calculate size of fixed memory buffers
13323 */
13324
13325 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13326 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13327
13328 device_param->size_root_css = size_root_css;
13329 device_param->size_markov_css = size_markov_css;
13330
13331 uint size_results = KERNEL_THREADS * sizeof (uint);
13332
13333 device_param->size_results = size_results;
13334
13335 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13336 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13337
13338 uint size_plains = digests_cnt * sizeof (plain_t);
13339 uint size_salts = salts_cnt * sizeof (salt_t);
13340 uint size_esalts = salts_cnt * esalt_size;
13341
13342 device_param->size_plains = size_plains;
13343 device_param->size_digests = size_digests;
13344 device_param->size_shown = size_shown;
13345 device_param->size_salts = size_salts;
13346
13347 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13348 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13349 uint size_tm = 32 * sizeof (bs_word_t);
13350
13351 // scryptV stuff
13352
13353 u64 size_scryptV = 1;
13354
13355 if ((hash_mode == 8900) || (hash_mode == 9300))
13356 {
13357 uint tmto_start = 0;
13358 uint tmto_stop = 10;
13359
13360 if (scrypt_tmto)
13361 {
13362 tmto_start = scrypt_tmto;
13363 }
13364 else
13365 {
13366 // in case the user did not specify the tmto manually
13367 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13368 // but set the lower end only in case the user has a device with too less memory
13369
13370 if (hash_mode == 8900)
13371 {
13372 if (device_param->vendor_id == VENDOR_ID_AMD)
13373 {
13374 tmto_start = 1;
13375 }
13376 else if (device_param->vendor_id == VENDOR_ID_NV)
13377 {
13378 tmto_start = 3;
13379 }
13380 }
13381 else if (hash_mode == 9300)
13382 {
13383 if (device_param->vendor_id == VENDOR_ID_AMD)
13384 {
13385 tmto_start = 3;
13386 }
13387 else if (device_param->vendor_id == VENDOR_ID_NV)
13388 {
13389 tmto_start = 5;
13390 }
13391 }
13392 }
13393
13394 if (quiet == 0) log_info ("");
13395
13396 uint shader_per_mp = 1;
13397
13398 if (device_param->vendor_id == VENDOR_ID_AMD)
13399 {
13400 shader_per_mp = 8;
13401 }
13402 else if (device_param->vendor_id == VENDOR_ID_NV)
13403 {
13404 shader_per_mp = 32;
13405 }
13406
13407 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13408 {
13409 // TODO: in theory the following calculation needs to be done per salt, not global
13410 // we assume all hashes have the same scrypt settings
13411
13412 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13413
13414 size_scryptV /= 1 << tmto;
13415
13416 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13417
13418 if (size_scryptV > device_param->device_maxmem_alloc)
13419 {
13420 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13421
13422 continue;
13423 }
13424
13425 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13426 {
13427 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13428 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13429 }
13430
13431 break;
13432 }
13433
13434 if (data.salts_buf[0].scrypt_phy == 0)
13435 {
13436 log_error ("ERROR: can't allocate enough device memory");
13437
13438 return -1;
13439 }
13440
13441 if (quiet == 0) log_info ("");
13442 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13443 }
13444
13445 /**
13446 * create input buffers on device : calculate size of dynamic size memory buffers
13447 */
13448
13449 uint kernel_threads = KERNEL_THREADS;
13450
13451 // some algorithms need a fixed kernel-threads count (mostly because of shared memory usage)
13452
13453 if (hash_mode == 3200) kernel_threads = 8;
13454 if (hash_mode == 9000) kernel_threads = 8;
13455
13456 /**
13457 * some algorithms need a fixed kernel-loops count
13458 */
13459
13460 if (hash_mode == 1500)
13461 {
13462 const u32 kernel_loops_fixed = 1024;
13463
13464 device_param->kernel_loops_min = kernel_loops_fixed;
13465 device_param->kernel_loops_max = kernel_loops_fixed;
13466 }
13467
13468 if (hash_mode == 3000)
13469 {
13470 const u32 kernel_loops_fixed = 1024;
13471
13472 device_param->kernel_loops_min = kernel_loops_fixed;
13473 device_param->kernel_loops_max = kernel_loops_fixed;
13474 }
13475
13476 if (hash_mode == 8900)
13477 {
13478 const u32 kernel_loops_fixed = 1;
13479
13480 device_param->kernel_loops_min = kernel_loops_fixed;
13481 device_param->kernel_loops_max = kernel_loops_fixed;
13482 }
13483
13484 if (hash_mode == 9300)
13485 {
13486 const u32 kernel_loops_fixed = 1;
13487
13488 device_param->kernel_loops_min = kernel_loops_fixed;
13489 device_param->kernel_loops_max = kernel_loops_fixed;
13490 }
13491
13492 if (hash_mode == 12500)
13493 {
13494 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
13495
13496 device_param->kernel_loops_min = kernel_loops_fixed;
13497 device_param->kernel_loops_max = kernel_loops_fixed;
13498 }
13499
13500 /**
13501 * some algorithms have a maximum kernel-loops count
13502 */
13503
13504 if (attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
13505 {
13506 if (data.salts_buf[0].salt_iter < device_param->kernel_loops_max)
13507 {
13508 device_param->kernel_loops_max = data.salts_buf[0].salt_iter;
13509 }
13510 }
13511
13512 /**
13513 * some algorithms need a special kernel-accel
13514 */
13515
13516 if (hash_mode == 8900)
13517 {
13518 device_param->kernel_accel_min = 1;
13519 device_param->kernel_accel_max = 64;
13520 }
13521
13522 if (hash_mode == 9300)
13523 {
13524 device_param->kernel_accel_min = 1;
13525 device_param->kernel_accel_max = 64;
13526 }
13527
13528 u32 kernel_accel_min = device_param->kernel_accel_min;
13529 u32 kernel_accel_max = device_param->kernel_accel_max;
13530
13531 // find out if we would request too much memory on memory blocks which are based on kernel_accel
13532
13533 uint size_pws = 4;
13534 uint size_tmps = 4;
13535 uint size_hooks = 4;
13536
13537 while (kernel_accel_max >= kernel_accel_min)
13538 {
13539 uint kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
13540
13541 // size_pws
13542
13543 size_pws = kernel_power_max * sizeof (pw_t);
13544
13545 // size_tmps
13546
13547 switch (hash_mode)
13548 {
13549 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
13550 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13551 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13552 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13553 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
13554 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
13555 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
13556 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
13557 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
13558 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
13559 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13560 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13561 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13562 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13563 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13564 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13565 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13566 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13567 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13568 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13569 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13570 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13571 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13572 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
13573 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
13574 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
13575 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
13576 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
13577 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13578 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13579 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
13580 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
13581 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13582 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
13583 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13584 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
13585 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
13586 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13587 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13588 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
13589 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
13590 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
13591 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13592 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
13593 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
13594 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
13595 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
13596 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13597 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
13598 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
13599 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
13600 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
13601 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13602 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
13603 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
13604 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
13605 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
13606 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
13607 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13608 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13609 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13610 };
13611
13612 // size_hooks
13613
13614 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13615 {
13616 // none yet
13617 }
13618
13619 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
13620 // if not, decrease amplifier and try again
13621
13622 int skip = 0;
13623
13624 if (size_pws > device_param->device_maxmem_alloc) skip = 1;
13625 if (size_tmps > device_param->device_maxmem_alloc) skip = 1;
13626 if (size_hooks > device_param->device_maxmem_alloc) skip = 1;
13627
13628 if (( bitmap_size
13629 + bitmap_size
13630 + bitmap_size
13631 + bitmap_size
13632 + bitmap_size
13633 + bitmap_size
13634 + bitmap_size
13635 + bitmap_size
13636 + size_bfs
13637 + size_combs
13638 + size_digests
13639 + size_esalts
13640 + size_hooks
13641 + size_markov_css
13642 + size_plains
13643 + size_pws
13644 + size_results
13645 + size_root_css
13646 + size_rules
13647 + size_rules_c
13648 + size_salts
13649 + size_scryptV
13650 + size_shown
13651 + size_tm
13652 + size_tmps) > device_param->device_global_mem) skip = 1;
13653
13654 if (skip == 1)
13655 {
13656 kernel_accel_max--;
13657
13658 continue;
13659 }
13660
13661 break;
13662 }
13663
13664 /*
13665 if (kernel_accel_max == 0)
13666 {
13667 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
13668
13669 return -1;
13670 }
13671 */
13672
13673 device_param->kernel_accel_min = kernel_accel_min;
13674 device_param->kernel_accel_max = kernel_accel_max;
13675
13676 /*
13677 if (kernel_accel_max < kernel_accel)
13678 {
13679 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
13680
13681 device_param->kernel_accel = kernel_accel_max;
13682 }
13683 */
13684
13685 device_param->size_pws = size_pws;
13686 device_param->size_tmps = size_tmps;
13687 device_param->size_hooks = size_hooks;
13688
13689 // do not confuse kernel_accel_max with kernel_accel here
13690
13691 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
13692
13693 device_param->kernel_threads = kernel_threads;
13694 device_param->kernel_power_user = kernel_power;
13695
13696 kernel_power_all += kernel_power;
13697
13698 /**
13699 * default building options
13700 */
13701
13702 char build_opts[1024] = { 0 };
13703
13704 // we don't have sm_* on vendors not NV but it doesn't matter
13705
13706 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);
13707
13708 /**
13709 * main kernel
13710 */
13711
13712 {
13713 /**
13714 * kernel source filename
13715 */
13716
13717 char source_file[256] = { 0 };
13718
13719 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13720
13721 struct stat sst;
13722
13723 if (stat (source_file, &sst) == -1)
13724 {
13725 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13726
13727 return -1;
13728 }
13729
13730 /**
13731 * kernel cached filename
13732 */
13733
13734 char cached_file[256] = { 0 };
13735
13736 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
13737
13738 int cached = 1;
13739
13740 struct stat cst;
13741
13742 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
13743 {
13744 cached = 0;
13745 }
13746
13747 /**
13748 * kernel compile or load
13749 */
13750
13751 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13752
13753 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13754
13755 if (force_jit_compilation == -1)
13756 {
13757 if (cached == 0)
13758 {
13759 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13760
13761 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13762
13763 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13764
13765 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
13766
13767 if (rc != 0)
13768 {
13769 device_param->skipped = true;
13770 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13771 continue;
13772 }
13773
13774 size_t binary_size;
13775
13776 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13777
13778 u8 *binary = (u8 *) mymalloc (binary_size);
13779
13780 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13781
13782 writeProgramBin (cached_file, binary, binary_size);
13783
13784 local_free (binary);
13785 }
13786 else
13787 {
13788 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13789
13790 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13791
13792 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13793
13794 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
13795 }
13796 }
13797 else
13798 {
13799 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13800
13801 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13802
13803 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13804
13805 char build_opts_update[1024] = { 0 };
13806
13807 if (force_jit_compilation == 1500)
13808 {
13809 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13810 }
13811 else if (force_jit_compilation == 8900)
13812 {
13813 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);
13814 }
13815 else
13816 {
13817 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
13818 }
13819
13820 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
13821
13822 if (rc != 0)
13823 {
13824 device_param->skipped = true;
13825
13826 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13827 }
13828 }
13829
13830 local_free (kernel_lengths);
13831 local_free (kernel_sources[0]);
13832 local_free (kernel_sources);
13833 }
13834
13835 /**
13836 * word generator kernel
13837 */
13838
13839 if (attack_mode != ATTACK_MODE_STRAIGHT)
13840 {
13841 /**
13842 * kernel mp source filename
13843 */
13844
13845 char source_file[256] = { 0 };
13846
13847 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
13848
13849 struct stat sst;
13850
13851 if (stat (source_file, &sst) == -1)
13852 {
13853 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13854
13855 return -1;
13856 }
13857
13858 /**
13859 * kernel mp cached filename
13860 */
13861
13862 char cached_file[256] = { 0 };
13863
13864 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
13865
13866 int cached = 1;
13867
13868 struct stat cst;
13869
13870 if (stat (cached_file, &cst) == -1)
13871 {
13872 cached = 0;
13873 }
13874
13875 /**
13876 * kernel compile or load
13877 */
13878
13879 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13880
13881 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13882
13883 if (cached == 0)
13884 {
13885 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13886
13887 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13888
13889 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13890
13891 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
13892
13893 if (rc != 0)
13894 {
13895 device_param->skipped = true;
13896 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13897 continue;
13898 }
13899
13900 size_t binary_size;
13901
13902 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13903
13904 u8 *binary = (u8 *) mymalloc (binary_size);
13905
13906 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13907
13908 writeProgramBin (cached_file, binary, binary_size);
13909
13910 local_free (binary);
13911 }
13912 else
13913 {
13914 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13915
13916 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13917
13918 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13919
13920 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
13921 }
13922
13923 local_free (kernel_lengths);
13924 local_free (kernel_sources[0]);
13925 local_free (kernel_sources);
13926 }
13927
13928 /**
13929 * amplifier kernel
13930 */
13931
13932 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13933 {
13934
13935 }
13936 else
13937 {
13938 /**
13939 * kernel amp source filename
13940 */
13941
13942 char source_file[256] = { 0 };
13943
13944 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
13945
13946 struct stat sst;
13947
13948 if (stat (source_file, &sst) == -1)
13949 {
13950 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13951
13952 return -1;
13953 }
13954
13955 /**
13956 * kernel amp cached filename
13957 */
13958
13959 char cached_file[256] = { 0 };
13960
13961 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
13962
13963 int cached = 1;
13964
13965 struct stat cst;
13966
13967 if (stat (cached_file, &cst) == -1)
13968 {
13969 cached = 0;
13970 }
13971
13972 /**
13973 * kernel compile or load
13974 */
13975
13976 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13977
13978 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13979
13980 if (cached == 0)
13981 {
13982 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13983
13984 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13985
13986 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13987
13988 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
13989
13990 if (rc != 0)
13991 {
13992 device_param->skipped = true;
13993 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13994 continue;
13995 }
13996
13997 size_t binary_size;
13998
13999 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14000
14001 u8 *binary = (u8 *) mymalloc (binary_size);
14002
14003 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14004
14005 writeProgramBin (cached_file, binary, binary_size);
14006
14007 local_free (binary);
14008 }
14009 else
14010 {
14011 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14012
14013 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14014
14015 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14016
14017 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
14018 }
14019
14020 local_free (kernel_lengths);
14021 local_free (kernel_sources[0]);
14022 local_free (kernel_sources);
14023 }
14024
14025 // some algorithm collide too fast, make that impossible
14026
14027 if (benchmark == 1)
14028 {
14029 ((uint *) digests_buf)[0] = -1;
14030 ((uint *) digests_buf)[1] = -1;
14031 ((uint *) digests_buf)[2] = -1;
14032 ((uint *) digests_buf)[3] = -1;
14033 }
14034
14035 /**
14036 * global buffers
14037 */
14038
14039 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14040 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14041 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
14042 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
14043 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14044 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14045 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14046 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14047 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14048 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14049 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14050 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14051 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
14052 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
14053 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
14054 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
14055 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
14056 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
14057
14058 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);
14059 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);
14060 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);
14061 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);
14062 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);
14063 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);
14064 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);
14065 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);
14066 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
14067 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
14068 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
14069
14070 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
14071 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
14072 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
14073 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
14074 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
14075 run_kernel_bzero (device_param, device_param->d_result, size_results);
14076
14077 /**
14078 * special buffers
14079 */
14080
14081 if (attack_kern == ATTACK_KERN_STRAIGHT)
14082 {
14083 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
14084 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
14085
14086 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
14087
14088 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
14089 }
14090 else if (attack_kern == ATTACK_KERN_COMBI)
14091 {
14092 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14093 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14094 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14095 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14096
14097 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
14098 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
14099 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14100 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14101 }
14102 else if (attack_kern == ATTACK_KERN_BF)
14103 {
14104 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14105 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14106 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
14107 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14108 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14109
14110 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
14111 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
14112 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
14113 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14114 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14115 }
14116
14117 if (size_esalts)
14118 {
14119 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
14120
14121 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
14122 }
14123
14124 /**
14125 * main host data
14126 */
14127
14128 uint *result = (uint *) mymalloc (size_results);
14129
14130 device_param->result = result;
14131
14132 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
14133
14134 device_param->pws_buf = pws_buf;
14135
14136 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
14137
14138 device_param->combs_buf = combs_buf;
14139
14140 void *hooks_buf = mymalloc (size_hooks);
14141
14142 device_param->hooks_buf = hooks_buf;
14143
14144 /**
14145 * kernel args
14146 */
14147
14148 device_param->kernel_params_buf32[21] = bitmap_mask;
14149 device_param->kernel_params_buf32[22] = bitmap_shift1;
14150 device_param->kernel_params_buf32[23] = bitmap_shift2;
14151 device_param->kernel_params_buf32[24] = 0; // salt_pos
14152 device_param->kernel_params_buf32[25] = 0; // loop_pos
14153 device_param->kernel_params_buf32[26] = 0; // loop_cnt
14154 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
14155 device_param->kernel_params_buf32[28] = 0; // digests_cnt
14156 device_param->kernel_params_buf32[29] = 0; // digests_offset
14157 device_param->kernel_params_buf32[30] = 0; // combs_mode
14158 device_param->kernel_params_buf32[31] = 0; // gid_max
14159
14160 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14161 ? &device_param->d_pws_buf
14162 : &device_param->d_pws_amp_buf;
14163 device_param->kernel_params[ 1] = &device_param->d_rules_c;
14164 device_param->kernel_params[ 2] = &device_param->d_combs_c;
14165 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
14166 device_param->kernel_params[ 4] = &device_param->d_tmps;
14167 device_param->kernel_params[ 5] = &device_param->d_hooks;
14168 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
14169 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
14170 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
14171 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
14172 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
14173 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
14174 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
14175 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
14176 device_param->kernel_params[14] = &device_param->d_plain_bufs;
14177 device_param->kernel_params[15] = &device_param->d_digests_buf;
14178 device_param->kernel_params[16] = &device_param->d_digests_shown;
14179 device_param->kernel_params[17] = &device_param->d_salt_bufs;
14180 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
14181 device_param->kernel_params[19] = &device_param->d_result;
14182 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
14183 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
14184 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
14185 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
14186 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
14187 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
14188 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
14189 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
14190 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
14191 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
14192 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
14193 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
14194
14195 device_param->kernel_params_mp_buf64[3] = 0;
14196 device_param->kernel_params_mp_buf32[4] = 0;
14197 device_param->kernel_params_mp_buf32[5] = 0;
14198 device_param->kernel_params_mp_buf32[6] = 0;
14199 device_param->kernel_params_mp_buf32[7] = 0;
14200 device_param->kernel_params_mp_buf32[8] = 0;
14201
14202 device_param->kernel_params_mp[0] = NULL;
14203 device_param->kernel_params_mp[1] = NULL;
14204 device_param->kernel_params_mp[2] = NULL;
14205 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
14206 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
14207 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
14208 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
14209 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
14210 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
14211
14212 device_param->kernel_params_mp_l_buf64[3] = 0;
14213 device_param->kernel_params_mp_l_buf32[4] = 0;
14214 device_param->kernel_params_mp_l_buf32[5] = 0;
14215 device_param->kernel_params_mp_l_buf32[6] = 0;
14216 device_param->kernel_params_mp_l_buf32[7] = 0;
14217 device_param->kernel_params_mp_l_buf32[8] = 0;
14218 device_param->kernel_params_mp_l_buf32[9] = 0;
14219
14220 device_param->kernel_params_mp_l[0] = NULL;
14221 device_param->kernel_params_mp_l[1] = NULL;
14222 device_param->kernel_params_mp_l[2] = NULL;
14223 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14224 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14225 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14226 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14227 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14228 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14229 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14230
14231 device_param->kernel_params_mp_r_buf64[3] = 0;
14232 device_param->kernel_params_mp_r_buf32[4] = 0;
14233 device_param->kernel_params_mp_r_buf32[5] = 0;
14234 device_param->kernel_params_mp_r_buf32[6] = 0;
14235 device_param->kernel_params_mp_r_buf32[7] = 0;
14236 device_param->kernel_params_mp_r_buf32[8] = 0;
14237
14238 device_param->kernel_params_mp_r[0] = NULL;
14239 device_param->kernel_params_mp_r[1] = NULL;
14240 device_param->kernel_params_mp_r[2] = NULL;
14241 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14242 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14243 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14244 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14245 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14246 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14247
14248 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14249 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14250
14251 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14252 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14253 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14254 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14255 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14256 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14257 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14258
14259 device_param->kernel_params_tb[0] = &device_param->d_pws_buf;
14260
14261 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14262 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14263
14264 /**
14265 * kernel name
14266 */
14267
14268 char kernel_name[64] = { 0 };
14269
14270 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14271 {
14272 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14273 {
14274 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14275
14276 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14277
14278 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14279
14280 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14281
14282 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14283
14284 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14285 }
14286 else
14287 {
14288 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14289
14290 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14291
14292 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14293
14294 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14295
14296 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14297
14298 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14299 }
14300
14301 if (data.attack_mode == ATTACK_MODE_BF)
14302 {
14303 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14304 {
14305 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tb", kern_type);
14306
14307 device_param->kernel_tb = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14308
14309 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14310
14311 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14312 }
14313 }
14314 }
14315 else
14316 {
14317 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14318
14319 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14320
14321 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14322
14323 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14324
14325 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14326
14327 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14328
14329 if (opts_type & OPTS_TYPE_HOOK12)
14330 {
14331 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14332
14333 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14334 }
14335
14336 if (opts_type & OPTS_TYPE_HOOK23)
14337 {
14338 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14339
14340 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14341 }
14342 }
14343
14344 for (uint i = 0; i <= 20; i++)
14345 {
14346 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14347 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14348 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14349
14350 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14351 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14352 }
14353
14354 for (uint i = 21; i <= 31; i++)
14355 {
14356 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14357 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14358 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14359
14360 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14361 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14362 }
14363
14364 if (attack_mode == ATTACK_MODE_BF)
14365 {
14366 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
14367 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
14368
14369 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14370 {
14371 hc_clSetKernelArg (data.ocl, device_param->kernel_tb, 0, sizeof (cl_mem), device_param->kernel_params_tb[0]);
14372
14373 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14374 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14375 }
14376 }
14377 else if (attack_mode == ATTACK_MODE_HYBRID1)
14378 {
14379 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14380 }
14381 else if (attack_mode == ATTACK_MODE_HYBRID2)
14382 {
14383 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14384 }
14385
14386 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14387 {
14388 // nothing to do
14389 }
14390 else
14391 {
14392 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
14393 }
14394
14395 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14396 {
14397 // nothing to do
14398 }
14399 else
14400 {
14401 for (uint i = 0; i < 5; i++)
14402 {
14403 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14404 }
14405
14406 for (uint i = 5; i < 7; i++)
14407 {
14408 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14409 }
14410 }
14411
14412 /**
14413 * Store initial fanspeed if gpu_temp_retain is enabled
14414 */
14415
14416 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
14417 int gpu_temp_retain_set = 0;
14418
14419 if (gpu_temp_disable == 0)
14420 {
14421 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14422 {
14423 hc_thread_mutex_lock (mux_adl);
14424
14425 if (data.hm_device[device_id].fan_supported == 1)
14426 {
14427 if (gpu_temp_retain_chgd == 0)
14428 {
14429 uint cur_temp = 0;
14430 uint default_temp = 0;
14431
14432 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);
14433
14434 if (ADL_rc == ADL_OK)
14435 {
14436 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14437
14438 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14439
14440 // special case with multi gpu setups: always use minimum retain
14441
14442 if (gpu_temp_retain_set == 0)
14443 {
14444 gpu_temp_retain = gpu_temp_retain_target;
14445 gpu_temp_retain_set = 1;
14446 }
14447 else
14448 {
14449 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14450 }
14451
14452 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14453 }
14454 }
14455
14456 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14457
14458 temp_retain_fanspeed_value[device_id] = fan_speed;
14459
14460 if (fan_speed == -1)
14461 {
14462 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14463
14464 temp_retain_fanspeed_value[device_id] = 0;
14465 }
14466 }
14467
14468 hc_thread_mutex_unlock (mux_adl);
14469 }
14470 }
14471
14472 /**
14473 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14474 */
14475
14476 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14477 {
14478 hc_thread_mutex_lock (mux_adl);
14479
14480 if (data.hm_device[device_id].od_version == 6)
14481 {
14482 int ADL_rc;
14483
14484 // check powertune capabilities first, if not available then skip device
14485
14486 int powertune_supported = 0;
14487
14488 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14489 {
14490 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14491
14492 return (-1);
14493 }
14494
14495 if (powertune_supported != 0)
14496 {
14497 // powercontrol settings
14498
14499 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14500
14501 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14502 {
14503 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14504 }
14505
14506 if (ADL_rc != ADL_OK)
14507 {
14508 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14509
14510 return (-1);
14511 }
14512
14513 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14514 {
14515 log_error ("ERROR: Failed to set new ADL PowerControl values");
14516
14517 return (-1);
14518 }
14519
14520 // clocks
14521
14522 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14523
14524 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14525
14526 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)
14527 {
14528 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14529
14530 return (-1);
14531 }
14532
14533 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14534
14535 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14536
14537 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14538 {
14539 log_error ("ERROR: Failed to get ADL device capabilities");
14540
14541 return (-1);
14542 }
14543
14544 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14545 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14546
14547 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14548 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14549
14550 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14551 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14552
14553 // warning if profile has too low max values
14554
14555 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14556 {
14557 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14558 }
14559
14560 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14561 {
14562 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14563 }
14564
14565 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14566
14567 performance_state->iNumberOfPerformanceLevels = 2;
14568
14569 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14570 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14571 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14572 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14573
14574 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)
14575 {
14576 log_info ("ERROR: Failed to set ADL performance state");
14577
14578 return (-1);
14579 }
14580
14581 local_free (performance_state);
14582 }
14583 }
14584
14585 hc_thread_mutex_unlock (mux_adl);
14586 }
14587 #endif // HAVE_HWMON && HAVE_ADL
14588 }
14589
14590 data.kernel_power_all = kernel_power_all;
14591
14592 if (data.quiet == 0) log_info ("");
14593
14594 /**
14595 * Inform user which algorithm is checked and at which workload setting
14596 */
14597
14598 if (benchmark == 1)
14599 {
14600 quiet = 0;
14601
14602 data.quiet = quiet;
14603
14604 char *hash_type = strhashtype (data.hash_mode); // not a bug
14605
14606 log_info ("Hashtype: %s", hash_type);
14607 log_info ("");
14608 }
14609
14610 /**
14611 * keep track of the progress
14612 */
14613
14614 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14615 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14616 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14617
14618 /**
14619 * open filehandles
14620 */
14621
14622 #if _WIN
14623 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14624 {
14625 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14626
14627 return (-1);
14628 }
14629
14630 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14631 {
14632 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14633
14634 return (-1);
14635 }
14636
14637 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14638 {
14639 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14640
14641 return (-1);
14642 }
14643 #endif
14644
14645 /**
14646 * dictionary pad
14647 */
14648
14649 segment_size *= (1024 * 1024);
14650
14651 data.segment_size = segment_size;
14652
14653 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14654
14655 wl_data->buf = (char *) mymalloc (segment_size);
14656 wl_data->avail = segment_size;
14657 wl_data->incr = segment_size;
14658 wl_data->cnt = 0;
14659 wl_data->pos = 0;
14660
14661 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14662
14663 data.wordlist_mode = wordlist_mode;
14664
14665 cs_t *css_buf = NULL;
14666 uint css_cnt = 0;
14667 uint dictcnt = 0;
14668 uint maskcnt = 1;
14669 char **masks = NULL;
14670 char **dictfiles = NULL;
14671
14672 uint mask_from_file = 0;
14673
14674 if (attack_mode == ATTACK_MODE_STRAIGHT)
14675 {
14676 if (wordlist_mode == WL_MODE_FILE)
14677 {
14678 int wls_left = myargc - (optind + 1);
14679
14680 for (int i = 0; i < wls_left; i++)
14681 {
14682 char *l0_filename = myargv[optind + 1 + i];
14683
14684 struct stat l0_stat;
14685
14686 if (stat (l0_filename, &l0_stat) == -1)
14687 {
14688 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14689
14690 return (-1);
14691 }
14692
14693 uint is_dir = S_ISDIR (l0_stat.st_mode);
14694
14695 if (is_dir == 0)
14696 {
14697 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14698
14699 dictcnt++;
14700
14701 dictfiles[dictcnt - 1] = l0_filename;
14702 }
14703 else
14704 {
14705 // do not allow --keyspace w/ a directory
14706
14707 if (keyspace == 1)
14708 {
14709 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14710
14711 return (-1);
14712 }
14713
14714 char **dictionary_files = NULL;
14715
14716 dictionary_files = scan_directory (l0_filename);
14717
14718 if (dictionary_files != NULL)
14719 {
14720 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14721
14722 for (int d = 0; dictionary_files[d] != NULL; d++)
14723 {
14724 char *l1_filename = dictionary_files[d];
14725
14726 struct stat l1_stat;
14727
14728 if (stat (l1_filename, &l1_stat) == -1)
14729 {
14730 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14731
14732 return (-1);
14733 }
14734
14735 if (S_ISREG (l1_stat.st_mode))
14736 {
14737 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14738
14739 dictcnt++;
14740
14741 dictfiles[dictcnt - 1] = strdup (l1_filename);
14742 }
14743 }
14744 }
14745
14746 local_free (dictionary_files);
14747 }
14748 }
14749
14750 if (dictcnt < 1)
14751 {
14752 log_error ("ERROR: No usable dictionary file found.");
14753
14754 return (-1);
14755 }
14756 }
14757 else if (wordlist_mode == WL_MODE_STDIN)
14758 {
14759 dictcnt = 1;
14760 }
14761 }
14762 else if (attack_mode == ATTACK_MODE_COMBI)
14763 {
14764 // display
14765
14766 char *dictfile1 = myargv[optind + 1 + 0];
14767 char *dictfile2 = myargv[optind + 1 + 1];
14768
14769 // find the bigger dictionary and use as base
14770
14771 FILE *fp1 = NULL;
14772 FILE *fp2 = NULL;
14773
14774 struct stat tmp_stat;
14775
14776 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14777 {
14778 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14779
14780 return (-1);
14781 }
14782
14783 if (stat (dictfile1, &tmp_stat) == -1)
14784 {
14785 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14786
14787 fclose (fp1);
14788
14789 return (-1);
14790 }
14791
14792 if (S_ISDIR (tmp_stat.st_mode))
14793 {
14794 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14795
14796 fclose (fp1);
14797
14798 return (-1);
14799 }
14800
14801 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14802 {
14803 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14804
14805 fclose (fp1);
14806
14807 return (-1);
14808 }
14809
14810 if (stat (dictfile2, &tmp_stat) == -1)
14811 {
14812 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14813
14814 fclose (fp1);
14815 fclose (fp2);
14816
14817 return (-1);
14818 }
14819
14820 if (S_ISDIR (tmp_stat.st_mode))
14821 {
14822 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
14823
14824 fclose (fp1);
14825 fclose (fp2);
14826
14827 return (-1);
14828 }
14829
14830 data.combs_cnt = 1;
14831
14832 data.quiet = 1;
14833
14834 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
14835
14836 data.quiet = quiet;
14837
14838 if (words1_cnt == 0)
14839 {
14840 log_error ("ERROR: %s: empty file", dictfile1);
14841
14842 fclose (fp1);
14843 fclose (fp2);
14844
14845 return (-1);
14846 }
14847
14848 data.combs_cnt = 1;
14849
14850 data.quiet = 1;
14851
14852 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
14853
14854 data.quiet = quiet;
14855
14856 if (words2_cnt == 0)
14857 {
14858 log_error ("ERROR: %s: empty file", dictfile2);
14859
14860 fclose (fp1);
14861 fclose (fp2);
14862
14863 return (-1);
14864 }
14865
14866 fclose (fp1);
14867 fclose (fp2);
14868
14869 data.dictfile = dictfile1;
14870 data.dictfile2 = dictfile2;
14871
14872 if (words1_cnt >= words2_cnt)
14873 {
14874 data.combs_cnt = words2_cnt;
14875 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14876
14877 dictfiles = &data.dictfile;
14878
14879 dictcnt = 1;
14880 }
14881 else
14882 {
14883 data.combs_cnt = words1_cnt;
14884 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14885
14886 dictfiles = &data.dictfile2;
14887
14888 dictcnt = 1;
14889
14890 // we also have to switch wordlist related rules!
14891
14892 char *tmpc = data.rule_buf_l;
14893
14894 data.rule_buf_l = data.rule_buf_r;
14895 data.rule_buf_r = tmpc;
14896
14897 int tmpi = data.rule_len_l;
14898
14899 data.rule_len_l = data.rule_len_r;
14900 data.rule_len_r = tmpi;
14901 }
14902 }
14903 else if (attack_mode == ATTACK_MODE_BF)
14904 {
14905 char *mask = NULL;
14906
14907 maskcnt = 0;
14908
14909 if (benchmark == 0)
14910 {
14911 mask = myargv[optind + 1];
14912
14913 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
14914
14915 if ((optind + 2) <= myargc)
14916 {
14917 struct stat file_stat;
14918
14919 if (stat (mask, &file_stat) == -1)
14920 {
14921 maskcnt = 1;
14922
14923 masks[maskcnt - 1] = mystrdup (mask);
14924 }
14925 else
14926 {
14927 int wls_left = myargc - (optind + 1);
14928
14929 uint masks_avail = INCR_MASKS;
14930
14931 for (int i = 0; i < wls_left; i++)
14932 {
14933 if (i != 0)
14934 {
14935 mask = myargv[optind + 1 + i];
14936
14937 if (stat (mask, &file_stat) == -1)
14938 {
14939 log_error ("ERROR: %s: %s", mask, strerror (errno));
14940
14941 return (-1);
14942 }
14943 }
14944
14945 uint is_file = S_ISREG (file_stat.st_mode);
14946
14947 if (is_file == 1)
14948 {
14949 FILE *mask_fp;
14950
14951 if ((mask_fp = fopen (mask, "r")) == NULL)
14952 {
14953 log_error ("ERROR: %s: %s", mask, strerror (errno));
14954
14955 return (-1);
14956 }
14957
14958 char line_buf[BUFSIZ] = { 0 };
14959
14960 while (!feof (mask_fp))
14961 {
14962 memset (line_buf, 0, BUFSIZ);
14963
14964 int line_len = fgetl (mask_fp, line_buf);
14965
14966 if (line_len == 0) continue;
14967
14968 if (line_buf[0] == '#') continue;
14969
14970 if (masks_avail == maskcnt)
14971 {
14972 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14973
14974 masks_avail += INCR_MASKS;
14975 }
14976
14977 masks[maskcnt] = mystrdup (line_buf);
14978
14979 maskcnt++;
14980 }
14981
14982 fclose (mask_fp);
14983 }
14984 else
14985 {
14986 log_error ("ERROR: %s: unsupported file-type", mask);
14987
14988 return (-1);
14989 }
14990 }
14991
14992 mask_from_file = 1;
14993 }
14994 }
14995 else
14996 {
14997 custom_charset_1 = (char *) "?l?d?u";
14998 custom_charset_2 = (char *) "?l?d";
14999 custom_charset_3 = (char *) "?l?d*!$@_";
15000
15001 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15002 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15003 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15004
15005 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
15006
15007 wordlist_mode = WL_MODE_MASK;
15008
15009 data.wordlist_mode = wordlist_mode;
15010
15011 increment = 1;
15012
15013 maskcnt = 1;
15014 }
15015 }
15016 else
15017 {
15018 /**
15019 * generate full masks and charsets
15020 */
15021
15022 masks = (char **) mymalloc (sizeof (char *));
15023
15024 switch (hash_mode)
15025 {
15026 case 1731: pw_min = 5;
15027 pw_max = 5;
15028 mask = mystrdup ("?b?b?b?b?b");
15029 break;
15030 case 12500: pw_min = 5;
15031 pw_max = 5;
15032 mask = mystrdup ("?b?b?b?b?b");
15033 break;
15034 default: pw_min = 7;
15035 pw_max = 7;
15036 mask = mystrdup ("?b?b?b?b?b?b?b");
15037 break;
15038 }
15039
15040 maskcnt = 1;
15041
15042 masks[maskcnt - 1] = mystrdup (mask);
15043
15044 wordlist_mode = WL_MODE_MASK;
15045
15046 data.wordlist_mode = wordlist_mode;
15047
15048 increment = 1;
15049 }
15050
15051 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
15052
15053 if (increment)
15054 {
15055 if (increment_min > pw_min) pw_min = increment_min;
15056
15057 if (increment_max < pw_max) pw_max = increment_max;
15058 }
15059 }
15060 else if (attack_mode == ATTACK_MODE_HYBRID1)
15061 {
15062 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15063
15064 // display
15065
15066 char *mask = myargv[myargc - 1];
15067
15068 maskcnt = 0;
15069
15070 masks = (char **) mymalloc (1 * sizeof (char *));
15071
15072 // mod
15073
15074 struct stat file_stat;
15075
15076 if (stat (mask, &file_stat) == -1)
15077 {
15078 maskcnt = 1;
15079
15080 masks[maskcnt - 1] = mystrdup (mask);
15081 }
15082 else
15083 {
15084 uint is_file = S_ISREG (file_stat.st_mode);
15085
15086 if (is_file == 1)
15087 {
15088 FILE *mask_fp;
15089
15090 if ((mask_fp = fopen (mask, "r")) == NULL)
15091 {
15092 log_error ("ERROR: %s: %s", mask, strerror (errno));
15093
15094 return (-1);
15095 }
15096
15097 char line_buf[BUFSIZ] = { 0 };
15098
15099 uint masks_avail = 1;
15100
15101 while (!feof (mask_fp))
15102 {
15103 memset (line_buf, 0, BUFSIZ);
15104
15105 int line_len = fgetl (mask_fp, line_buf);
15106
15107 if (line_len == 0) continue;
15108
15109 if (line_buf[0] == '#') continue;
15110
15111 if (masks_avail == maskcnt)
15112 {
15113 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15114
15115 masks_avail += INCR_MASKS;
15116 }
15117
15118 masks[maskcnt] = mystrdup (line_buf);
15119
15120 maskcnt++;
15121 }
15122
15123 fclose (mask_fp);
15124
15125 mask_from_file = 1;
15126 }
15127 else
15128 {
15129 maskcnt = 1;
15130
15131 masks[maskcnt - 1] = mystrdup (mask);
15132 }
15133 }
15134
15135 // base
15136
15137 int wls_left = myargc - (optind + 2);
15138
15139 for (int i = 0; i < wls_left; i++)
15140 {
15141 char *filename = myargv[optind + 1 + i];
15142
15143 struct stat file_stat;
15144
15145 if (stat (filename, &file_stat) == -1)
15146 {
15147 log_error ("ERROR: %s: %s", filename, strerror (errno));
15148
15149 return (-1);
15150 }
15151
15152 uint is_dir = S_ISDIR (file_stat.st_mode);
15153
15154 if (is_dir == 0)
15155 {
15156 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15157
15158 dictcnt++;
15159
15160 dictfiles[dictcnt - 1] = filename;
15161 }
15162 else
15163 {
15164 // do not allow --keyspace w/ a directory
15165
15166 if (keyspace == 1)
15167 {
15168 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15169
15170 return (-1);
15171 }
15172
15173 char **dictionary_files = NULL;
15174
15175 dictionary_files = scan_directory (filename);
15176
15177 if (dictionary_files != NULL)
15178 {
15179 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15180
15181 for (int d = 0; dictionary_files[d] != NULL; d++)
15182 {
15183 char *l1_filename = dictionary_files[d];
15184
15185 struct stat l1_stat;
15186
15187 if (stat (l1_filename, &l1_stat) == -1)
15188 {
15189 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15190
15191 return (-1);
15192 }
15193
15194 if (S_ISREG (l1_stat.st_mode))
15195 {
15196 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15197
15198 dictcnt++;
15199
15200 dictfiles[dictcnt - 1] = strdup (l1_filename);
15201 }
15202 }
15203 }
15204
15205 local_free (dictionary_files);
15206 }
15207 }
15208
15209 if (dictcnt < 1)
15210 {
15211 log_error ("ERROR: No usable dictionary file found.");
15212
15213 return (-1);
15214 }
15215
15216 if (increment)
15217 {
15218 maskcnt = 0;
15219
15220 uint mask_min = increment_min; // we can't reject smaller masks here
15221 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15222
15223 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15224 {
15225 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15226
15227 if (cur_mask == NULL) break;
15228
15229 masks[maskcnt] = cur_mask;
15230
15231 maskcnt++;
15232
15233 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15234 }
15235 }
15236 }
15237 else if (attack_mode == ATTACK_MODE_HYBRID2)
15238 {
15239 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15240
15241 // display
15242
15243 char *mask = myargv[optind + 1 + 0];
15244
15245 maskcnt = 0;
15246
15247 masks = (char **) mymalloc (1 * sizeof (char *));
15248
15249 // mod
15250
15251 struct stat file_stat;
15252
15253 if (stat (mask, &file_stat) == -1)
15254 {
15255 maskcnt = 1;
15256
15257 masks[maskcnt - 1] = mystrdup (mask);
15258 }
15259 else
15260 {
15261 uint is_file = S_ISREG (file_stat.st_mode);
15262
15263 if (is_file == 1)
15264 {
15265 FILE *mask_fp;
15266
15267 if ((mask_fp = fopen (mask, "r")) == NULL)
15268 {
15269 log_error ("ERROR: %s: %s", mask, strerror (errno));
15270
15271 return (-1);
15272 }
15273
15274 char line_buf[BUFSIZ] = { 0 };
15275
15276 uint masks_avail = 1;
15277
15278 while (!feof (mask_fp))
15279 {
15280 memset (line_buf, 0, BUFSIZ);
15281
15282 int line_len = fgetl (mask_fp, line_buf);
15283
15284 if (line_len == 0) continue;
15285
15286 if (line_buf[0] == '#') continue;
15287
15288 if (masks_avail == maskcnt)
15289 {
15290 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15291
15292 masks_avail += INCR_MASKS;
15293 }
15294
15295 masks[maskcnt] = mystrdup (line_buf);
15296
15297 maskcnt++;
15298 }
15299
15300 fclose (mask_fp);
15301
15302 mask_from_file = 1;
15303 }
15304 else
15305 {
15306 maskcnt = 1;
15307
15308 masks[maskcnt - 1] = mystrdup (mask);
15309 }
15310 }
15311
15312 // base
15313
15314 int wls_left = myargc - (optind + 2);
15315
15316 for (int i = 0; i < wls_left; i++)
15317 {
15318 char *filename = myargv[optind + 2 + i];
15319
15320 struct stat file_stat;
15321
15322 if (stat (filename, &file_stat) == -1)
15323 {
15324 log_error ("ERROR: %s: %s", filename, strerror (errno));
15325
15326 return (-1);
15327 }
15328
15329 uint is_dir = S_ISDIR (file_stat.st_mode);
15330
15331 if (is_dir == 0)
15332 {
15333 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15334
15335 dictcnt++;
15336
15337 dictfiles[dictcnt - 1] = filename;
15338 }
15339 else
15340 {
15341 // do not allow --keyspace w/ a directory
15342
15343 if (keyspace == 1)
15344 {
15345 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15346
15347 return (-1);
15348 }
15349
15350 char **dictionary_files = NULL;
15351
15352 dictionary_files = scan_directory (filename);
15353
15354 if (dictionary_files != NULL)
15355 {
15356 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15357
15358 for (int d = 0; dictionary_files[d] != NULL; d++)
15359 {
15360 char *l1_filename = dictionary_files[d];
15361
15362 struct stat l1_stat;
15363
15364 if (stat (l1_filename, &l1_stat) == -1)
15365 {
15366 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15367
15368 return (-1);
15369 }
15370
15371 if (S_ISREG (l1_stat.st_mode))
15372 {
15373 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15374
15375 dictcnt++;
15376
15377 dictfiles[dictcnt - 1] = strdup (l1_filename);
15378 }
15379 }
15380 }
15381
15382 local_free (dictionary_files);
15383 }
15384 }
15385
15386 if (dictcnt < 1)
15387 {
15388 log_error ("ERROR: No usable dictionary file found.");
15389
15390 return (-1);
15391 }
15392
15393 if (increment)
15394 {
15395 maskcnt = 0;
15396
15397 uint mask_min = increment_min; // we can't reject smaller masks here
15398 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15399
15400 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15401 {
15402 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15403
15404 if (cur_mask == NULL) break;
15405
15406 masks[maskcnt] = cur_mask;
15407
15408 maskcnt++;
15409
15410 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15411 }
15412 }
15413 }
15414
15415 data.pw_min = pw_min;
15416 data.pw_max = pw_max;
15417
15418 /**
15419 * weak hash check
15420 */
15421
15422 if (weak_hash_threshold >= salts_cnt)
15423 {
15424 hc_device_param_t *device_param = NULL;
15425
15426 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15427 {
15428 device_param = &data.devices_param[device_id];
15429
15430 if (device_param->skipped) continue;
15431
15432 break;
15433 }
15434
15435 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15436
15437 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15438 {
15439 weak_hash_check (device_param, salt_pos);
15440 }
15441 }
15442
15443 // Display hack, guarantee that there is at least one \r before real start
15444
15445 if (data.quiet == 0) log_info_nn ("");
15446
15447 /**
15448 * status and monitor threads
15449 */
15450
15451 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15452
15453 hc_thread_t i_thread = 0;
15454
15455 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15456 {
15457 hc_thread_create (i_thread, thread_keypress, &benchmark);
15458 }
15459
15460 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15461
15462 uint ni_threads_cnt = 0;
15463
15464 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15465
15466 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15467
15468 ni_threads_cnt++;
15469
15470 /**
15471 * Outfile remove
15472 */
15473
15474 if (keyspace == 0)
15475 {
15476 if (outfile_check_timer != 0)
15477 {
15478 if (data.outfile_check_directory != NULL)
15479 {
15480 if ((hash_mode != 5200) &&
15481 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15482 (hash_mode != 9000))
15483 {
15484 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15485
15486 ni_threads_cnt++;
15487 }
15488 else
15489 {
15490 outfile_check_timer = 0;
15491 }
15492 }
15493 else
15494 {
15495 outfile_check_timer = 0;
15496 }
15497 }
15498 }
15499
15500 /**
15501 * Inform the user if we got some hashes remove because of the pot file remove feature
15502 */
15503
15504 if (data.quiet == 0)
15505 {
15506 if (potfile_remove_cracks > 0)
15507 {
15508 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15509 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15510 }
15511 }
15512
15513 data.outfile_check_timer = outfile_check_timer;
15514
15515 /**
15516 * main loop
15517 */
15518
15519 char **induction_dictionaries = NULL;
15520
15521 int induction_dictionaries_cnt = 0;
15522
15523 hcstat_table_t *root_table_buf = NULL;
15524 hcstat_table_t *markov_table_buf = NULL;
15525
15526 uint initial_restore_done = 0;
15527
15528 data.maskcnt = maskcnt;
15529
15530 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15531 {
15532 if (data.devices_status == STATUS_CRACKED) break;
15533
15534 data.devices_status = STATUS_INIT;
15535
15536 if (maskpos > rd->maskpos)
15537 {
15538 rd->dictpos = 0;
15539 }
15540
15541 rd->maskpos = maskpos;
15542 data.maskpos = maskpos;
15543
15544 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15545 {
15546 char *mask = masks[maskpos];
15547
15548 if (mask_from_file == 1)
15549 {
15550 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15551
15552 char *str_ptr;
15553 uint str_pos;
15554
15555 uint mask_offset = 0;
15556
15557 uint separator_cnt;
15558
15559 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15560 {
15561 str_ptr = strstr (mask + mask_offset, ",");
15562
15563 if (str_ptr == NULL) break;
15564
15565 str_pos = str_ptr - mask;
15566
15567 // escaped separator, i.e. "\,"
15568
15569 if (str_pos > 0)
15570 {
15571 if (mask[str_pos - 1] == '\\')
15572 {
15573 separator_cnt --;
15574
15575 mask_offset = str_pos + 1;
15576
15577 continue;
15578 }
15579 }
15580
15581 // reset the offset
15582
15583 mask_offset = 0;
15584
15585 mask[str_pos] = '\0';
15586
15587 switch (separator_cnt)
15588 {
15589 case 0:
15590 mp_reset_usr (mp_usr, 0);
15591
15592 custom_charset_1 = mask;
15593 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15594 break;
15595
15596 case 1:
15597 mp_reset_usr (mp_usr, 1);
15598
15599 custom_charset_2 = mask;
15600 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15601 break;
15602
15603 case 2:
15604 mp_reset_usr (mp_usr, 2);
15605
15606 custom_charset_3 = mask;
15607 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15608 break;
15609
15610 case 3:
15611 mp_reset_usr (mp_usr, 3);
15612
15613 custom_charset_4 = mask;
15614 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15615 break;
15616 }
15617
15618 mask = mask + str_pos + 1;
15619 }
15620 }
15621
15622 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15623 {
15624 if (maskpos > 0)
15625 {
15626 local_free (css_buf);
15627 local_free (data.root_css_buf);
15628 local_free (data.markov_css_buf);
15629
15630 local_free (masks[maskpos - 1]);
15631 }
15632
15633 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15634
15635 data.mask = mask;
15636 data.css_cnt = css_cnt;
15637 data.css_buf = css_buf;
15638
15639 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15640
15641 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15642
15643 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15644 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15645
15646 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15647
15648 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15649
15650 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15651 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15652
15653 data.root_css_buf = root_css_buf;
15654 data.markov_css_buf = markov_css_buf;
15655
15656 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15657
15658 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15659
15660 local_free (root_table_buf);
15661 local_free (markov_table_buf);
15662
15663 // args
15664
15665 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15666 {
15667 hc_device_param_t *device_param = &data.devices_param[device_id];
15668
15669 if (device_param->skipped) continue;
15670
15671 device_param->kernel_params_mp[0] = &device_param->d_combs;
15672 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15673 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15674
15675 device_param->kernel_params_mp_buf64[3] = 0;
15676 device_param->kernel_params_mp_buf32[4] = css_cnt;
15677 device_param->kernel_params_mp_buf32[5] = 0;
15678 device_param->kernel_params_mp_buf32[6] = 0;
15679 device_param->kernel_params_mp_buf32[7] = 0;
15680
15681 if (attack_mode == ATTACK_MODE_HYBRID1)
15682 {
15683 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15684 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15685 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15686 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15687 }
15688 else if (attack_mode == ATTACK_MODE_HYBRID2)
15689 {
15690 device_param->kernel_params_mp_buf32[5] = 0;
15691 device_param->kernel_params_mp_buf32[6] = 0;
15692 device_param->kernel_params_mp_buf32[7] = 0;
15693 }
15694
15695 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]);
15696 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]);
15697 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]);
15698
15699 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);
15700 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);
15701 }
15702 }
15703 else if (attack_mode == ATTACK_MODE_BF)
15704 {
15705 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15706
15707 if (increment)
15708 {
15709 for (uint i = 0; i < dictcnt; i++)
15710 {
15711 local_free (dictfiles[i]);
15712 }
15713
15714 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15715 {
15716 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15717
15718 if (l1_filename == NULL) break;
15719
15720 dictcnt++;
15721
15722 dictfiles[dictcnt - 1] = l1_filename;
15723 }
15724 }
15725 else
15726 {
15727 dictcnt++;
15728
15729 dictfiles[dictcnt - 1] = mask;
15730 }
15731
15732 if (dictcnt == 0)
15733 {
15734 log_error ("ERROR: Mask is too small");
15735
15736 return (-1);
15737 }
15738 }
15739 }
15740
15741 free (induction_dictionaries);
15742
15743 // induction_dictionaries_cnt = 0; // implied
15744
15745 if (attack_mode != ATTACK_MODE_BF)
15746 {
15747 if (keyspace == 0)
15748 {
15749 induction_dictionaries = scan_directory (induction_directory);
15750
15751 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15752 }
15753 }
15754
15755 if (induction_dictionaries_cnt)
15756 {
15757 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15758 }
15759
15760 /**
15761 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15762 */
15763 if (keyspace == 1)
15764 {
15765 if ((maskcnt > 1) || (dictcnt > 1))
15766 {
15767 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15768
15769 return (-1);
15770 }
15771 }
15772
15773 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15774 {
15775 char *subid = logfile_generate_subid ();
15776
15777 data.subid = subid;
15778
15779 logfile_sub_msg ("START");
15780
15781 data.devices_status = STATUS_INIT;
15782
15783 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
15784 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
15785 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
15786
15787 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15788
15789 data.cpt_pos = 0;
15790
15791 data.cpt_start = time (NULL);
15792
15793 data.cpt_total = 0;
15794
15795 if (data.restore == 0)
15796 {
15797 rd->words_cur = skip;
15798
15799 skip = 0;
15800
15801 data.skip = 0;
15802 }
15803
15804 data.ms_paused = 0;
15805
15806 data.words_cur = rd->words_cur;
15807
15808 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15809 {
15810 hc_device_param_t *device_param = &data.devices_param[device_id];
15811
15812 if (device_param->skipped) continue;
15813
15814 device_param->speed_pos = 0;
15815
15816 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
15817 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
15818 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
15819
15820 device_param->exec_pos = 0;
15821
15822 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
15823
15824 device_param->kernel_power = device_param->kernel_power_user;
15825
15826 device_param->outerloop_pos = 0;
15827 device_param->outerloop_left = 0;
15828 device_param->innerloop_pos = 0;
15829 device_param->innerloop_left = 0;
15830
15831 // some more resets:
15832
15833 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
15834
15835 device_param->pws_cnt = 0;
15836
15837 device_param->words_off = 0;
15838 device_param->words_done = 0;
15839 }
15840
15841 data.kernel_power_div = 0;
15842
15843 // figure out some workload
15844
15845 if (attack_mode == ATTACK_MODE_STRAIGHT)
15846 {
15847 if (data.wordlist_mode == WL_MODE_FILE)
15848 {
15849 char *dictfile = NULL;
15850
15851 if (induction_dictionaries_cnt)
15852 {
15853 dictfile = induction_dictionaries[0];
15854 }
15855 else
15856 {
15857 dictfile = dictfiles[dictpos];
15858 }
15859
15860 data.dictfile = dictfile;
15861
15862 logfile_sub_string (dictfile);
15863
15864 for (uint i = 0; i < rp_files_cnt; i++)
15865 {
15866 logfile_sub_var_string ("rulefile", rp_files[i]);
15867 }
15868
15869 FILE *fd2 = fopen (dictfile, "rb");
15870
15871 if (fd2 == NULL)
15872 {
15873 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15874
15875 return (-1);
15876 }
15877
15878 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15879
15880 fclose (fd2);
15881
15882 if (data.words_cnt == 0)
15883 {
15884 if (data.devices_status == STATUS_CRACKED) break;
15885 if (data.devices_status == STATUS_ABORTED) break;
15886
15887 dictpos++;
15888
15889 continue;
15890 }
15891 }
15892 }
15893 else if (attack_mode == ATTACK_MODE_COMBI)
15894 {
15895 char *dictfile = data.dictfile;
15896 char *dictfile2 = data.dictfile2;
15897
15898 logfile_sub_string (dictfile);
15899 logfile_sub_string (dictfile2);
15900
15901 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
15902 {
15903 FILE *fd2 = fopen (dictfile, "rb");
15904
15905 if (fd2 == NULL)
15906 {
15907 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15908
15909 return (-1);
15910 }
15911
15912 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15913
15914 fclose (fd2);
15915 }
15916 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
15917 {
15918 FILE *fd2 = fopen (dictfile2, "rb");
15919
15920 if (fd2 == NULL)
15921 {
15922 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15923
15924 return (-1);
15925 }
15926
15927 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
15928
15929 fclose (fd2);
15930 }
15931
15932 if (data.words_cnt == 0)
15933 {
15934 if (data.devices_status == STATUS_CRACKED) break;
15935 if (data.devices_status == STATUS_ABORTED) break;
15936
15937 dictpos++;
15938
15939 continue;
15940 }
15941 }
15942 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15943 {
15944 char *dictfile = NULL;
15945
15946 if (induction_dictionaries_cnt)
15947 {
15948 dictfile = induction_dictionaries[0];
15949 }
15950 else
15951 {
15952 dictfile = dictfiles[dictpos];
15953 }
15954
15955 data.dictfile = dictfile;
15956
15957 char *mask = data.mask;
15958
15959 logfile_sub_string (dictfile);
15960 logfile_sub_string (mask);
15961
15962 FILE *fd2 = fopen (dictfile, "rb");
15963
15964 if (fd2 == NULL)
15965 {
15966 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15967
15968 return (-1);
15969 }
15970
15971 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15972
15973 fclose (fd2);
15974
15975 if (data.words_cnt == 0)
15976 {
15977 if (data.devices_status == STATUS_CRACKED) break;
15978 if (data.devices_status == STATUS_ABORTED) break;
15979
15980 dictpos++;
15981
15982 continue;
15983 }
15984 }
15985 else if (attack_mode == ATTACK_MODE_BF)
15986 {
15987 local_free (css_buf);
15988 local_free (data.root_css_buf);
15989 local_free (data.markov_css_buf);
15990
15991 char *mask = dictfiles[dictpos];
15992
15993 logfile_sub_string (mask);
15994
15995 // base
15996
15997 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15998
15999 if (opts_type & OPTS_TYPE_PT_UNICODE)
16000 {
16001 uint css_cnt_unicode = css_cnt * 2;
16002
16003 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
16004
16005 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
16006 {
16007 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
16008
16009 css_buf_unicode[j + 1].cs_buf[0] = 0;
16010 css_buf_unicode[j + 1].cs_len = 1;
16011 }
16012
16013 free (css_buf);
16014
16015 css_buf = css_buf_unicode;
16016 css_cnt = css_cnt_unicode;
16017 }
16018
16019 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
16020
16021 uint mask_min = pw_min;
16022 uint mask_max = pw_max;
16023
16024 if (opts_type & OPTS_TYPE_PT_UNICODE)
16025 {
16026 mask_min *= 2;
16027 mask_max *= 2;
16028 }
16029
16030 if ((css_cnt < mask_min) || (css_cnt > mask_max))
16031 {
16032 if (css_cnt < mask_min)
16033 {
16034 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
16035 }
16036
16037 if (css_cnt > mask_max)
16038 {
16039 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
16040 }
16041
16042 // skip to next mask
16043
16044 dictpos++;
16045
16046 rd->dictpos = dictpos;
16047
16048 logfile_sub_msg ("STOP");
16049
16050 continue;
16051 }
16052
16053 uint save_css_cnt = css_cnt;
16054
16055 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16056 {
16057 if (opti_type & OPTI_TYPE_APPENDED_SALT)
16058 {
16059 uint salt_len = (uint) data.salts_buf[0].salt_len;
16060 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
16061
16062 uint css_cnt_salt = css_cnt + salt_len;
16063
16064 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
16065
16066 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
16067
16068 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
16069 {
16070 css_buf_salt[j].cs_buf[0] = salt_buf[i];
16071 css_buf_salt[j].cs_len = 1;
16072 }
16073
16074 free (css_buf);
16075
16076 css_buf = css_buf_salt;
16077 css_cnt = css_cnt_salt;
16078 }
16079 }
16080
16081 data.mask = mask;
16082 data.css_cnt = css_cnt;
16083 data.css_buf = css_buf;
16084
16085 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
16086
16087 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16088
16089 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16090
16091 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16092 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16093
16094 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16095
16096 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16097
16098 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16099 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16100
16101 data.root_css_buf = root_css_buf;
16102 data.markov_css_buf = markov_css_buf;
16103
16104 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16105
16106 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16107
16108 local_free (root_table_buf);
16109 local_free (markov_table_buf);
16110
16111 // copy + args
16112
16113 uint css_cnt_l = css_cnt;
16114 uint css_cnt_r;
16115
16116 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16117 {
16118 if (save_css_cnt < 6)
16119 {
16120 css_cnt_r = 1;
16121 }
16122 else if (save_css_cnt == 6)
16123 {
16124 css_cnt_r = 2;
16125 }
16126 else
16127 {
16128 if (opts_type & OPTS_TYPE_PT_UNICODE)
16129 {
16130 if (save_css_cnt == 8 || save_css_cnt == 10)
16131 {
16132 css_cnt_r = 2;
16133 }
16134 else
16135 {
16136 css_cnt_r = 4;
16137 }
16138 }
16139 else
16140 {
16141 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
16142 {
16143 css_cnt_r = 3;
16144 }
16145 else
16146 {
16147 css_cnt_r = 4;
16148 }
16149 }
16150 }
16151 }
16152 else
16153 {
16154 css_cnt_r = 1;
16155
16156 /* unfinished code?
16157 int sum = css_buf[css_cnt_r - 1].cs_len;
16158
16159 for (uint i = 1; i < 4 && i < css_cnt; i++)
16160 {
16161 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
16162
16163 css_cnt_r++;
16164
16165 sum *= css_buf[css_cnt_r - 1].cs_len;
16166 }
16167 */
16168 }
16169
16170 css_cnt_l -= css_cnt_r;
16171
16172 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
16173
16174 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16175 {
16176 hc_device_param_t *device_param = &data.devices_param[device_id];
16177
16178 if (device_param->skipped) continue;
16179
16180 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
16181 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
16182 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
16183
16184 device_param->kernel_params_mp_l_buf64[3] = 0;
16185 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
16186 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
16187 device_param->kernel_params_mp_l_buf32[6] = 0;
16188 device_param->kernel_params_mp_l_buf32[7] = 0;
16189 device_param->kernel_params_mp_l_buf32[8] = 0;
16190
16191 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
16192 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
16193 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
16194 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
16195
16196 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
16197 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
16198 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
16199
16200 device_param->kernel_params_mp_r_buf64[3] = 0;
16201 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
16202 device_param->kernel_params_mp_r_buf32[5] = 0;
16203 device_param->kernel_params_mp_r_buf32[6] = 0;
16204 device_param->kernel_params_mp_r_buf32[7] = 0;
16205
16206 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]);
16207 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]);
16208 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]);
16209
16210 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]);
16211 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]);
16212 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]);
16213
16214 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);
16215 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);
16216 }
16217 }
16218
16219 u64 words_base = data.words_cnt;
16220
16221 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16222 {
16223 if (data.kernel_rules_cnt)
16224 {
16225 words_base /= data.kernel_rules_cnt;
16226 }
16227 }
16228 else if (data.attack_kern == ATTACK_KERN_COMBI)
16229 {
16230 if (data.combs_cnt)
16231 {
16232 words_base /= data.combs_cnt;
16233 }
16234 }
16235 else if (data.attack_kern == ATTACK_KERN_BF)
16236 {
16237 if (data.bfs_cnt)
16238 {
16239 words_base /= data.bfs_cnt;
16240 }
16241 }
16242
16243 data.words_base = words_base;
16244
16245 if (keyspace == 1)
16246 {
16247 log_info ("%llu", (unsigned long long int) words_base);
16248
16249 return (0);
16250 }
16251
16252 if (data.words_cur > data.words_base)
16253 {
16254 log_error ("ERROR: restore value greater keyspace");
16255
16256 return (-1);
16257 }
16258
16259 if (data.words_cur)
16260 {
16261 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16262 {
16263 for (uint i = 0; i < data.salts_cnt; i++)
16264 {
16265 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16266 }
16267 }
16268 else if (data.attack_kern == ATTACK_KERN_COMBI)
16269 {
16270 for (uint i = 0; i < data.salts_cnt; i++)
16271 {
16272 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16273 }
16274 }
16275 else if (data.attack_kern == ATTACK_KERN_BF)
16276 {
16277 for (uint i = 0; i < data.salts_cnt; i++)
16278 {
16279 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16280 }
16281 }
16282 }
16283
16284 /*
16285 * Inform user about possible slow speeds
16286 */
16287
16288 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16289 {
16290 if (data.words_base < kernel_power_all)
16291 {
16292 if (quiet == 0)
16293 {
16294 log_info ("");
16295 log_info ("ATTENTION!");
16296 log_info (" The wordlist or mask you are using is too small.");
16297 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
16298 log_info (" The cracking speed will drop.");
16299 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16300 log_info ("");
16301 }
16302 }
16303 }
16304
16305 /*
16306 * Update loopback file
16307 */
16308
16309 if (loopback == 1)
16310 {
16311 time_t now;
16312
16313 time (&now);
16314
16315 uint random_num = get_random_num (0, 9999);
16316
16317 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16318
16319 data.loopback_file = loopback_file;
16320 }
16321
16322 /*
16323 * Update dictionary statistic
16324 */
16325
16326 if (keyspace == 0)
16327 {
16328 dictstat_fp = fopen (dictstat, "wb");
16329
16330 if (dictstat_fp)
16331 {
16332 lock_file (dictstat_fp);
16333
16334 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16335
16336 fclose (dictstat_fp);
16337 }
16338 }
16339
16340 data.devices_status = STATUS_RUNNING;
16341
16342 if (initial_restore_done == 0)
16343 {
16344 if (data.restore_disable == 0) cycle_restore ();
16345
16346 initial_restore_done = 1;
16347 }
16348
16349 hc_timer_set (&data.timer_running);
16350
16351 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16352 {
16353 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16354 {
16355 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16356 if (quiet == 0) fflush (stdout);
16357 }
16358 }
16359 else if (wordlist_mode == WL_MODE_STDIN)
16360 {
16361 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16362 if (data.quiet == 0) log_info ("");
16363 }
16364
16365 time_t runtime_start;
16366
16367 time (&runtime_start);
16368
16369 data.runtime_start = runtime_start;
16370
16371 /**
16372 * create cracker threads
16373 */
16374
16375 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
16376
16377 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16378 {
16379 hc_device_param_t *device_param = &devices_param[device_id];
16380
16381 if (wordlist_mode == WL_MODE_STDIN)
16382 {
16383 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16384 }
16385 else
16386 {
16387 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16388 }
16389 }
16390
16391 // wait for crack threads to exit
16392
16393 hc_thread_wait (data.devices_cnt, c_threads);
16394
16395 local_free (c_threads);
16396
16397 data.restore = 0;
16398
16399 // finalize task
16400
16401 logfile_sub_var_uint ("status-after-work", data.devices_status);
16402
16403 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16404
16405 if (data.devices_status == STATUS_CRACKED) break;
16406 if (data.devices_status == STATUS_ABORTED) break;
16407
16408 if (data.devices_status == STATUS_BYPASS)
16409 {
16410 data.devices_status = STATUS_RUNNING;
16411 }
16412
16413 if (induction_dictionaries_cnt)
16414 {
16415 unlink (induction_dictionaries[0]);
16416 }
16417
16418 free (induction_dictionaries);
16419
16420 if (attack_mode != ATTACK_MODE_BF)
16421 {
16422 induction_dictionaries = scan_directory (induction_directory);
16423
16424 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16425 }
16426
16427 if (benchmark == 0)
16428 {
16429 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16430 {
16431 if (quiet == 0) clear_prompt ();
16432
16433 if (quiet == 0) log_info ("");
16434
16435 if (status == 1)
16436 {
16437 status_display ();
16438 }
16439 else
16440 {
16441 if (quiet == 0) status_display ();
16442 }
16443
16444 if (quiet == 0) log_info ("");
16445 }
16446 }
16447
16448 if (attack_mode == ATTACK_MODE_BF)
16449 {
16450 dictpos++;
16451
16452 rd->dictpos = dictpos;
16453 }
16454 else
16455 {
16456 if (induction_dictionaries_cnt)
16457 {
16458 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16459 }
16460 else
16461 {
16462 dictpos++;
16463
16464 rd->dictpos = dictpos;
16465 }
16466 }
16467
16468 time_t runtime_stop;
16469
16470 time (&runtime_stop);
16471
16472 data.runtime_stop = runtime_stop;
16473
16474 logfile_sub_uint (runtime_start);
16475 logfile_sub_uint (runtime_stop);
16476
16477 logfile_sub_msg ("STOP");
16478
16479 global_free (subid);
16480 }
16481
16482 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16483
16484 if (data.devices_status == STATUS_CRACKED) break;
16485 if (data.devices_status == STATUS_ABORTED) break;
16486 if (data.devices_status == STATUS_QUIT) break;
16487
16488 if (data.devices_status == STATUS_BYPASS)
16489 {
16490 data.devices_status = STATUS_RUNNING;
16491 }
16492 }
16493
16494 // 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
16495
16496 if (attack_mode == ATTACK_MODE_STRAIGHT)
16497 {
16498 if (data.wordlist_mode == WL_MODE_FILE)
16499 {
16500 if (data.dictfile == NULL)
16501 {
16502 if (dictfiles != NULL)
16503 {
16504 data.dictfile = dictfiles[0];
16505
16506 hc_timer_set (&data.timer_running);
16507 }
16508 }
16509 }
16510 }
16511 // NOTE: combi is okay because it is already set beforehand
16512 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16513 {
16514 if (data.dictfile == NULL)
16515 {
16516 if (dictfiles != NULL)
16517 {
16518 hc_timer_set (&data.timer_running);
16519
16520 data.dictfile = dictfiles[0];
16521 }
16522 }
16523 }
16524 else if (attack_mode == ATTACK_MODE_BF)
16525 {
16526 if (data.mask == NULL)
16527 {
16528 hc_timer_set (&data.timer_running);
16529
16530 data.mask = masks[0];
16531 }
16532 }
16533
16534 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16535 {
16536 data.devices_status = STATUS_EXHAUSTED;
16537 }
16538
16539 // if cracked / aborted remove last induction dictionary
16540
16541 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16542 {
16543 struct stat induct_stat;
16544
16545 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16546 {
16547 unlink (induction_dictionaries[file_pos]);
16548 }
16549 }
16550
16551 // wait for non-interactive threads
16552
16553 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16554 {
16555 hc_thread_wait (1, &ni_threads[thread_idx]);
16556 }
16557
16558 local_free (ni_threads);
16559
16560 // wait for interactive threads
16561
16562 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16563 {
16564 hc_thread_wait (1, &i_thread);
16565 }
16566
16567 // we dont need restore file anymore
16568 if (data.restore_disable == 0)
16569 {
16570 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16571 {
16572 unlink (eff_restore_file);
16573 unlink (new_restore_file);
16574 }
16575 else
16576 {
16577 cycle_restore ();
16578 }
16579 }
16580
16581 // finally save left hashes
16582
16583 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16584 {
16585 save_hash ();
16586 }
16587
16588 /**
16589 * Clean up
16590 */
16591
16592 if (benchmark == 1)
16593 {
16594 status_benchmark ();
16595
16596 log_info ("");
16597 }
16598 else
16599 {
16600 if (quiet == 0) clear_prompt ();
16601
16602 if (quiet == 0) log_info ("");
16603
16604 if (status == 1)
16605 {
16606 status_display ();
16607 }
16608 else
16609 {
16610 if (quiet == 0) status_display ();
16611 }
16612
16613 if (quiet == 0) log_info ("");
16614 }
16615
16616 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16617 {
16618 hc_device_param_t *device_param = &data.devices_param[device_id];
16619
16620 if (device_param->skipped) continue;
16621
16622 local_free (device_param->result);
16623
16624 local_free (device_param->combs_buf);
16625
16626 local_free (device_param->hooks_buf);
16627
16628 local_free (device_param->device_name);
16629
16630 local_free (device_param->device_name_chksum);
16631
16632 local_free (device_param->device_version);
16633
16634 local_free (device_param->driver_version);
16635
16636 if (device_param->pws_buf) myfree (device_param->pws_buf);
16637 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
16638 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
16639 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
16640 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
16641 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
16642 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
16643 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
16644 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
16645 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
16646 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
16647 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
16648 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
16649 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
16650 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
16651 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
16652 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
16653 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
16654 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
16655 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
16656 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
16657 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
16658 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
16659 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
16660 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
16661 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
16662 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
16663 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
16664 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
16665
16666 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
16667 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
16668 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
16669 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
16670 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
16671 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
16672 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
16673 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
16674 if (device_param->kernel_tb) hc_clReleaseKernel (data.ocl, device_param->kernel_tb);
16675 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
16676 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
16677
16678 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
16679 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
16680 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
16681
16682 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
16683 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
16684 }
16685
16686 // reset default fan speed
16687
16688 #ifdef HAVE_HWMON
16689 if (gpu_temp_disable == 0)
16690 {
16691 #ifdef HAVE_ADL
16692 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16693 {
16694 hc_thread_mutex_lock (mux_adl);
16695
16696 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16697 {
16698 hc_device_param_t *device_param = &data.devices_param[device_id];
16699
16700 if (device_param->skipped) continue;
16701
16702 if (data.hm_device[device_id].fan_supported == 1)
16703 {
16704 int fanspeed = temp_retain_fanspeed_value[device_id];
16705
16706 if (fanspeed == -1) continue;
16707
16708 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
16709
16710 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
16711 }
16712 }
16713
16714 hc_thread_mutex_unlock (mux_adl);
16715 }
16716 #endif // HAVE_ADL
16717 }
16718
16719 #ifdef HAVE_ADL
16720 // reset power tuning
16721
16722 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16723 {
16724 hc_thread_mutex_lock (mux_adl);
16725
16726 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16727 {
16728 hc_device_param_t *device_param = &data.devices_param[device_id];
16729
16730 if (device_param->skipped) continue;
16731
16732 if (data.hm_device[device_id].od_version == 6)
16733 {
16734 // check powertune capabilities first, if not available then skip device
16735
16736 int powertune_supported = 0;
16737
16738 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
16739 {
16740 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16741
16742 return (-1);
16743 }
16744
16745 if (powertune_supported != 0)
16746 {
16747 // powercontrol settings
16748
16749 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)
16750 {
16751 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16752
16753 return (-1);
16754 }
16755
16756 // clocks
16757
16758 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16759
16760 performance_state->iNumberOfPerformanceLevels = 2;
16761
16762 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
16763 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
16764 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
16765 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
16766
16767 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)
16768 {
16769 log_info ("ERROR: Failed to restore ADL performance state");
16770
16771 return (-1);
16772 }
16773
16774 local_free (performance_state);
16775 }
16776 }
16777 }
16778
16779 hc_thread_mutex_unlock (mux_adl);
16780 }
16781 #endif // HAVE_ADL
16782
16783 if (gpu_temp_disable == 0)
16784 {
16785 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
16786 if (data.hm_nv)
16787 {
16788 #if defined(LINUX) && defined(HAVE_NVML)
16789
16790 hm_NVML_nvmlShutdown (data.hm_nv);
16791
16792 nvml_close (data.hm_nv);
16793
16794 #elif defined(WIN) && (HAVE_NVAPI)
16795
16796 hm_NvAPI_Unload (data.hm_nv);
16797
16798 nvapi_close (data.hm_nv);
16799
16800 #endif
16801
16802 data.hm_nv = NULL;
16803 }
16804 #endif
16805
16806 #ifdef HAVE_ADL
16807 if (data.hm_amd)
16808 {
16809 hm_ADL_Main_Control_Destroy (data.hm_amd);
16810
16811 adl_close (data.hm_amd);
16812 data.hm_amd = NULL;
16813 }
16814 #endif
16815 }
16816 #endif // HAVE_HWMON
16817
16818 // free memory
16819
16820 local_free (masks);
16821
16822 local_free (dictstat_base);
16823
16824 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
16825 {
16826 pot_t *pot_ptr = &pot[pot_pos];
16827
16828 hash_t *hash = &pot_ptr->hash;
16829
16830 local_free (hash->digest);
16831
16832 if (isSalted)
16833 {
16834 local_free (hash->salt);
16835 }
16836 }
16837
16838 local_free (pot);
16839
16840 local_free (all_kernel_rules_cnt);
16841 local_free (all_kernel_rules_buf);
16842
16843 local_free (wl_data->buf);
16844 local_free (wl_data);
16845
16846 local_free (bitmap_s1_a);
16847 local_free (bitmap_s1_b);
16848 local_free (bitmap_s1_c);
16849 local_free (bitmap_s1_d);
16850 local_free (bitmap_s2_a);
16851 local_free (bitmap_s2_b);
16852 local_free (bitmap_s2_c);
16853 local_free (bitmap_s2_d);
16854
16855 #ifdef HAVE_HWMON
16856 local_free (temp_retain_fanspeed_value);
16857 #ifdef HAVE_ADL
16858 local_free (od_clock_mem_status);
16859 local_free (od_power_control_status);
16860 #endif // ADL
16861 #endif
16862
16863 global_free (devices_param);
16864
16865 global_free (kernel_rules_buf);
16866
16867 global_free (root_css_buf);
16868 global_free (markov_css_buf);
16869
16870 global_free (digests_buf);
16871 global_free (digests_shown);
16872 global_free (digests_shown_tmp);
16873
16874 global_free (salts_buf);
16875 global_free (salts_shown);
16876
16877 global_free (esalts_buf);
16878
16879 global_free (words_progress_done);
16880 global_free (words_progress_rejected);
16881 global_free (words_progress_restored);
16882
16883 if (pot_fp) fclose (pot_fp);
16884
16885 if (data.devices_status == STATUS_QUIT) break;
16886 }
16887
16888 // destroy others mutex
16889
16890 hc_thread_mutex_delete (mux_dispatcher);
16891 hc_thread_mutex_delete (mux_counter);
16892 hc_thread_mutex_delete (mux_display);
16893 hc_thread_mutex_delete (mux_adl);
16894
16895 // free memory
16896
16897 local_free (eff_restore_file);
16898 local_free (new_restore_file);
16899
16900 local_free (rd);
16901
16902 // tuning db
16903
16904 tuning_db_destroy (tuning_db);
16905
16906 // loopback
16907
16908 local_free (loopback_file);
16909
16910 if (loopback == 1) unlink (loopback_file);
16911
16912 // induction directory
16913
16914 if (induction_dir == NULL)
16915 {
16916 if (attack_mode != ATTACK_MODE_BF)
16917 {
16918 if (rmdir (induction_directory) == -1)
16919 {
16920 if (errno == ENOENT)
16921 {
16922 // good, we can ignore
16923 }
16924 else if (errno == ENOTEMPTY)
16925 {
16926 // good, we can ignore
16927 }
16928 else
16929 {
16930 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
16931
16932 return (-1);
16933 }
16934 }
16935
16936 local_free (induction_directory);
16937 }
16938 }
16939
16940 // outfile-check directory
16941
16942 if (outfile_check_dir == NULL)
16943 {
16944 if (rmdir (outfile_check_directory) == -1)
16945 {
16946 if (errno == ENOENT)
16947 {
16948 // good, we can ignore
16949 }
16950 else if (errno == ENOTEMPTY)
16951 {
16952 // good, we can ignore
16953 }
16954 else
16955 {
16956 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
16957
16958 return (-1);
16959 }
16960 }
16961
16962 local_free (outfile_check_directory);
16963 }
16964
16965 time_t proc_stop;
16966
16967 time (&proc_stop);
16968
16969 logfile_top_uint (proc_start);
16970 logfile_top_uint (proc_stop);
16971
16972 logfile_top_msg ("STOP");
16973
16974 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
16975 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
16976
16977 if (data.ocl) ocl_close (data.ocl);
16978
16979 if (data.devices_status == STATUS_ABORTED) return 2;
16980 if (data.devices_status == STATUS_QUIT) return 2;
16981 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
16982 if (data.devices_status == STATUS_EXHAUSTED) return 1;
16983 if (data.devices_status == STATUS_CRACKED) return 0;
16984
16985 return -1;
16986 }
Hashcat additions to support pwdhash