projects / hashcat.git / blob
? search:


def3c645c16e5d14c6952f153090edbdc6343e90
[hashcat.git] / src / hashcat.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 = "hashcat";
19 const uint VERSION_BIN = 300;
20 const uint RESTORE_MIN = 300;
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 RESTORE 0
37 #define RESTORE_TIMER 60
38 #define RESTORE_DISABLE 0
39 #define STATUS 0
40 #define STATUS_TIMER 10
41 #define STATUS_AUTOMAT 0
42 #define LOOPBACK 0
43 #define WEAK_HASH_THRESHOLD 100
44 #define SHOW 0
45 #define LEFT 0
46 #define USERNAME 0
47 #define REMOVE 0
48 #define REMOVE_TIMER 60
49 #define SKIP 0
50 #define LIMIT 0
51 #define KEYSPACE 0
52 #define POTFILE_DISABLE 0
53 #define DEBUG_MODE 0
54 #define RP_GEN 0
55 #define RP_GEN_FUNC_MIN 1
56 #define RP_GEN_FUNC_MAX 4
57 #define RP_GEN_SEED 0
58 #define RULE_BUF_L ":"
59 #define RULE_BUF_R ":"
60 #define FORCE 0
61 #define RUNTIME 0
62 #define HEX_CHARSET 0
63 #define HEX_SALT 0
64 #define HEX_WORDLIST 0
65 #define OUTFILE_FORMAT 3
66 #define OUTFILE_AUTOHEX 1
67 #define OUTFILE_CHECK_TIMER 5
68 #define ATTACK_MODE 0
69 #define HASH_MODE 0
70 #define SEGMENT_SIZE 32
71 #define INCREMENT 0
72 #define INCREMENT_MIN 1
73 #define INCREMENT_MAX PW_MAX
74 #define SEPARATOR ':'
75 #define BITMAP_MIN 16
76 #define BITMAP_MAX 24
77 #define GPU_TEMP_DISABLE 0
78 #define GPU_TEMP_ABORT 90
79 #define GPU_TEMP_RETAIN 80
80 #define WORKLOAD_PROFILE 2
81 #define KERNEL_ACCEL 0
82 #define KERNEL_LOOPS 0
83 #define KERNEL_RULES 1024
84 #define KERNEL_COMBS 1024
85 #define KERNEL_BFS 1024
86 #define KERNEL_THREADS_MAX 256
87 #define KERNEL_THREADS_MAX_CPU 16
88 #define POWERTUNE_ENABLE 0
89 #define LOGFILE_DISABLE 0
90 #define SCRYPT_TMTO 0
91 #define OPENCL_VECTOR_WIDTH 0
92
93 #define WL_MODE_STDIN 1
94 #define WL_MODE_FILE 2
95 #define WL_MODE_MASK 3
96
97 #define HL_MODE_FILE 4
98 #define HL_MODE_ARG 5
99
100 #define HLFMTS_CNT 11
101 #define HLFMT_HASHCAT 0
102 #define HLFMT_PWDUMP 1
103 #define HLFMT_PASSWD 2
104 #define HLFMT_SHADOW 3
105 #define HLFMT_DCC 4
106 #define HLFMT_DCC2 5
107 #define HLFMT_NETNTLM1 7
108 #define HLFMT_NETNTLM2 8
109 #define HLFMT_NSLDAP 9
110 #define HLFMT_NSLDAPS 10
111
112 #define HLFMT_TEXT_HASHCAT "native hashcat"
113 #define HLFMT_TEXT_PWDUMP "pwdump"
114 #define HLFMT_TEXT_PASSWD "passwd"
115 #define HLFMT_TEXT_SHADOW "shadow"
116 #define HLFMT_TEXT_DCC "DCC"
117 #define HLFMT_TEXT_DCC2 "DCC 2"
118 #define HLFMT_TEXT_NETNTLM1 "NetNTLMv1"
119 #define HLFMT_TEXT_NETNTLM2 "NetNTLMv2"
120 #define HLFMT_TEXT_NSLDAP "nsldap"
121 #define HLFMT_TEXT_NSLDAPS "nsldaps"
122
123 #define ATTACK_MODE_STRAIGHT 0
124 #define ATTACK_MODE_COMBI 1
125 #define ATTACK_MODE_TOGGLE 2
126 #define ATTACK_MODE_BF 3
127 #define ATTACK_MODE_PERM 4
128 #define ATTACK_MODE_TABLE 5
129 #define ATTACK_MODE_HYBRID1 6
130 #define ATTACK_MODE_HYBRID2 7
131 #define ATTACK_MODE_NONE 100
132
133 #define ATTACK_KERN_STRAIGHT 0
134 #define ATTACK_KERN_COMBI 1
135 #define ATTACK_KERN_BF 3
136 #define ATTACK_KERN_NONE 100
137
138 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
139 #define ATTACK_EXEC_INSIDE_KERNEL 11
140
141 #define COMBINATOR_MODE_BASE_LEFT 10001
142 #define COMBINATOR_MODE_BASE_RIGHT 10002
143
144 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
145 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
146
147 #define MAX_CUT_TRIES 4
148
149 #define MAX_DICTSTAT 10000
150
151 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 137
152
153 #define global_free(attr) \
154 { \
155 myfree ((void *) data.attr); \
156 \
157 data.attr = NULL; \
158 }
159
160 #define local_free(attr) \
161 { \
162 myfree ((void *) attr); \
163 \
164 attr = NULL; \
165 }
166
167 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
168 {
169 900,
170 0,
171 5100,
172 100,
173 1400,
174 10800,
175 1700,
176 5000,
177 10100,
178 6000,
179 6100,
180 6900,
181 11700,
182 11800,
183 400,
184 8900,
185 11900,
186 12000,
187 10900,
188 12100,
189 23,
190 2500,
191 5300,
192 5400,
193 5500,
194 5600,
195 7300,
196 7500,
197 13100,
198 8300,
199 11100,
200 11200,
201 11400,
202 121,
203 2611,
204 2711,
205 2811,
206 8400,
207 11,
208 2612,
209 7900,
210 21,
211 11000,
212 124,
213 10000,
214 3711,
215 7600,
216 12,
217 131,
218 132,
219 1731,
220 200,
221 300,
222 3100,
223 112,
224 12300,
225 8000,
226 141,
227 1441,
228 1600,
229 12600,
230 1421,
231 101,
232 111,
233 1711,
234 3000,
235 1000,
236 1100,
237 2100,
238 12800,
239 1500,
240 12400,
241 500,
242 3200,
243 7400,
244 1800,
245 122,
246 1722,
247 7100,
248 6300,
249 6700,
250 6400,
251 6500,
252 2400,
253 2410,
254 5700,
255 9200,
256 9300,
257 22,
258 501,
259 5800,
260 8100,
261 8500,
262 7200,
263 9900,
264 7700,
265 7800,
266 10300,
267 8600,
268 8700,
269 9100,
270 133,
271 13500,
272 11600,
273 13600,
274 12500,
275 13000,
276 13200,
277 13300,
278 6211,
279 6221,
280 6231,
281 6241,
282 8800,
283 12900,
284 12200,
285 9700,
286 9710,
287 9800,
288 9810,
289 9400,
290 9500,
291 9600,
292 10400,
293 10410,
294 10500,
295 10600,
296 10700,
297 9000,
298 5200,
299 6800,
300 6600,
301 8200,
302 11300,
303 12700,
304 13400,
305 125
306 };
307
308 /**
309 * types
310 */
311
312 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
313
314 /**
315 * globals
316 */
317
318 static unsigned int full01 = 0x01010101;
319 static unsigned int full80 = 0x80808080;
320
321 int SUPPRESS_OUTPUT = 0;
322
323 hc_thread_mutex_t mux_adl;
324 hc_thread_mutex_t mux_counter;
325 hc_thread_mutex_t mux_dispatcher;
326 hc_thread_mutex_t mux_display;
327
328 hc_global_data_t data;
329
330 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
331
332 const char *USAGE_MINI[] =
333 {
334 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
335 "",
336 "Try --help for more help.",
337 NULL
338 };
339
340 const char *USAGE_BIG[] =
341 {
342 "%s, advanced password recovery",
343 "",
344 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
345 "",
346 "=======",
347 "Options",
348 "=======",
349 "",
350 "* General:",
351 "",
352 " -m, --hash-type=NUM Hash-type, see references below",
353 " -a, --attack-mode=NUM Attack-mode, see references below",
354 " -V, --version Print version",
355 " -h, --help Print help",
356 " --quiet Suppress output",
357 "",
358 "* Misc:",
359 "",
360 " --hex-charset Assume charset is given in hex",
361 " --hex-salt Assume salt is given in hex",
362 " --hex-wordlist Assume words in wordlist is given in hex",
363 " --force Ignore warnings",
364 " --status Enable automatic update of the status-screen",
365 " --status-timer=NUM Seconds between status-screen update",
366 " --status-automat Display the status view in a machine readable format",
367 " --loopback Add new plains to induct directory",
368 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
369 "",
370 "* Markov:",
371 "",
372 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
373 " --markov-disable Disables markov-chains, emulates classic brute-force",
374 " --markov-classic Enables classic markov-chains, no per-position enhancement",
375 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
376 "",
377 "* Session:",
378 "",
379 " --runtime=NUM Abort session after NUM seconds of runtime",
380 " --session=STR Define specific session name",
381 " --restore Restore session from --session",
382 " --restore-disable Do not write restore file",
383 "",
384 "* Files:",
385 "",
386 " -o, --outfile=FILE Define outfile for recovered hash",
387 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
388 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
389 " --outfile-check-timer=NUM Seconds between outfile checks",
390 " -p, --separator=CHAR Separator char for hashlists and outfile",
391 " --show Show cracked passwords only",
392 " --left Show un-cracked passwords only",
393 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
394 " --remove Enable remove of hash once it is cracked",
395 " --remove-timer=NUM Update input hash file each NUM seconds",
396 " --potfile-disable Do not write potfile",
397 " --potfile-path Specific path to potfile",
398 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
399 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
400 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
401 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
402 " --logfile-disable Disable the logfile",
403 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
404 "",
405 "* Resources:",
406 "",
407 " -b, --benchmark Run benchmark",
408 " --benchmark-repeats=NUM Repeat the kernel on the device NUM times to increase benchmark accuracy",
409 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
410 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
411 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
412 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
413 " --opencl-platforms=STR OpenCL platforms to use, separate with comma",
414 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
415 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
416 " --opencl-vector-width=NUM OpenCL vector-width (either 1, 2, 4, 8 or 16), overrides value from device query",
417 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
418 " -n, --kernel-accel=NUM Workload tuning, increase the outer-loop step size",
419 " -u, --kernel-loops=NUM Workload tuning, increase the inner-loop step size",
420 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
421 #ifdef HAVE_HWMON
422 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
423 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
424 #ifdef HAVE_ADL
425 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
426 #endif
427 #endif
428 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
429 "",
430 "* Distributed:",
431 "",
432 " -s, --skip=NUM Skip number of words",
433 " -l, --limit=NUM Limit number of words",
434 " --keyspace Show keyspace base:mod values and quit",
435 "",
436 "* Rules:",
437 "",
438 " -j, --rule-left=RULE Single rule applied to each word from left dict",
439 " -k, --rule-right=RULE Single rule applied to each word from right dict",
440 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
441 " -g, --generate-rules=NUM Generate NUM random rules",
442 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
443 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
444 " --generate-rules-seed=NUM Force RNG seed to NUM",
445 "",
446 "* Custom charsets:",
447 "",
448 " -1, --custom-charset1=CS User-defined charsets",
449 " -2, --custom-charset2=CS Example:",
450 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
451 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
452 "",
453 "* Increment:",
454 "",
455 " -i, --increment Enable increment mode",
456 " --increment-min=NUM Start incrementing at NUM",
457 " --increment-max=NUM Stop incrementing at NUM",
458 "",
459 "==========",
460 "References",
461 "==========",
462 "",
463 "* Workload Profile:",
464 "",
465 " 1 = Interactive performance profile, kernel execution runtime to 8ms, lower latency desktop, lower speed",
466 " 2 = Default performance profile, kernel execution runtime to 16ms, economic setting",
467 " 3 = Headless performance profile, kernel execution runtime to 96ms, higher latency desktop, higher speed",
468 "",
469 "* OpenCL device-types:",
470 "",
471 " 1 = CPU devices",
472 " 2 = GPU devices",
473 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
474 "",
475 "* Outfile Formats:",
476 "",
477 " 1 = hash[:salt]",
478 " 2 = plain",
479 " 3 = hash[:salt]:plain",
480 " 4 = hex_plain",
481 " 5 = hash[:salt]:hex_plain",
482 " 6 = plain:hex_plain",
483 " 7 = hash[:salt]:plain:hex_plain",
484 " 8 = crackpos",
485 " 9 = hash[:salt]:crackpos",
486 " 10 = plain:crackpos",
487 " 11 = hash[:salt]:plain:crackpos",
488 " 12 = hex_plain:crackpos",
489 " 13 = hash[:salt]:hex_plain:crackpos",
490 " 14 = plain:hex_plain:crackpos",
491 " 15 = hash[:salt]:plain:hex_plain:crackpos",
492 "",
493 "* Debug mode output formats (for hybrid mode only, by using rules):",
494 "",
495 " 1 = save finding rule",
496 " 2 = save original word",
497 " 3 = save original word and finding rule",
498 " 4 = save original word, finding rule and modified plain",
499 "",
500 "* Built-in charsets:",
501 "",
502 " ?l = abcdefghijklmnopqrstuvwxyz",
503 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
504 " ?d = 0123456789",
505 " ?s = !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
506 " ?a = ?l?u?d?s",
507 " ?b = 0x00 - 0xff",
508 "",
509 "* Attack modes:",
510 "",
511 " 0 = Straight",
512 " 1 = Combination",
513 " 3 = Brute-force",
514 " 6 = Hybrid dict + mask",
515 " 7 = Hybrid mask + dict",
516 "",
517 "* Hash types:",
518 "",
519 "[[ Roll-your-own: Raw Hashes ]]",
520 "",
521 " 900 = MD4",
522 " 0 = MD5",
523 " 5100 = Half MD5",
524 " 100 = SHA1",
525 " 10800 = SHA-384",
526 " 1400 = SHA-256",
527 " 1700 = SHA-512",
528 " 5000 = SHA-3(Keccak)",
529 " 10100 = SipHash",
530 " 6000 = RipeMD160",
531 " 6100 = Whirlpool",
532 " 6900 = GOST R 34.11-94",
533 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
534 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
535 "",
536 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
537 "",
538 " 10 = md5($pass.$salt)",
539 " 20 = md5($salt.$pass)",
540 " 30 = md5(unicode($pass).$salt)",
541 " 40 = md5($salt.unicode($pass))",
542 " 3800 = md5($salt.$pass.$salt)",
543 " 3710 = md5($salt.md5($pass))",
544 " 2600 = md5(md5($pass)",
545 " 4300 = md5(strtoupper(md5($pass)))",
546 " 4400 = md5(sha1($pass))",
547 " 110 = sha1($pass.$salt)",
548 " 120 = sha1($salt.$pass)",
549 " 130 = sha1(unicode($pass).$salt)",
550 " 140 = sha1($salt.unicode($pass))",
551 " 4500 = sha1(sha1($pass)",
552 " 4700 = sha1(md5($pass))",
553 " 4900 = sha1($salt.$pass.$salt)",
554 " 1410 = sha256($pass.$salt)",
555 " 1420 = sha256($salt.$pass)",
556 " 1430 = sha256(unicode($pass).$salt)",
557 " 1440 = sha256($salt.unicode($pass))",
558 " 1710 = sha512($pass.$salt)",
559 " 1720 = sha512($salt.$pass)",
560 " 1730 = sha512(unicode($pass).$salt)",
561 " 1740 = sha512($salt.unicode($pass))",
562 "",
563 "[[ Roll-your-own: Authenticated Hashes ]]",
564 "",
565 " 50 = HMAC-MD5 (key = $pass)",
566 " 60 = HMAC-MD5 (key = $salt)",
567 " 150 = HMAC-SHA1 (key = $pass)",
568 " 160 = HMAC-SHA1 (key = $salt)",
569 " 1450 = HMAC-SHA256 (key = $pass)",
570 " 1460 = HMAC-SHA256 (key = $salt)",
571 " 1750 = HMAC-SHA512 (key = $pass)",
572 " 1760 = HMAC-SHA512 (key = $salt)",
573 "",
574 "[[ Generic KDF ]]",
575 "",
576 " 400 = phpass",
577 " 8900 = scrypt",
578 " 11900 = PBKDF2-HMAC-MD5",
579 " 12000 = PBKDF2-HMAC-SHA1",
580 " 10900 = PBKDF2-HMAC-SHA256",
581 " 12100 = PBKDF2-HMAC-SHA512",
582 "",
583 "[[ Network protocols, Challenge-Response ]]",
584 "",
585 " 23 = Skype",
586 " 2500 = WPA/WPA2",
587 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
588 " 5300 = IKE-PSK MD5",
589 " 5400 = IKE-PSK SHA1",
590 " 5500 = NetNTLMv1",
591 " 5500 = NetNTLMv1 + ESS",
592 " 5600 = NetNTLMv2",
593 " 7300 = IPMI2 RAKP HMAC-SHA1",
594 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
595 " 8300 = DNSSEC (NSEC3)",
596 " 10200 = Cram MD5",
597 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
598 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
599 " 11400 = SIP digest authentication (MD5)",
600 " 13100 = Kerberos 5 TGS-REP etype 23",
601 "",
602 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
603 "",
604 " 121 = SMF (Simple Machines Forum)",
605 " 400 = phpBB3",
606 " 2611 = vBulletin < v3.8.5",
607 " 2711 = vBulletin > v3.8.5",
608 " 2811 = MyBB",
609 " 2811 = IPB (Invison Power Board)",
610 " 8400 = WBB3 (Woltlab Burning Board)",
611 " 11 = Joomla < 2.5.18",
612 " 400 = Joomla > 2.5.18",
613 " 400 = Wordpress",
614 " 2612 = PHPS",
615 " 7900 = Drupal7",
616 " 21 = osCommerce",
617 " 21 = xt:Commerce",
618 " 11000 = PrestaShop",
619 " 124 = Django (SHA-1)",
620 " 10000 = Django (PBKDF2-SHA256)",
621 " 3711 = Mediawiki B type",
622 " 7600 = Redmine",
623 "",
624 "[[ Database Server ]]",
625 "",
626 " 12 = PostgreSQL",
627 " 131 = MSSQL(2000)",
628 " 132 = MSSQL(2005)",
629 " 1731 = MSSQL(2012)",
630 " 1731 = MSSQL(2014)",
631 " 200 = MySQL323",
632 " 300 = MySQL4.1/MySQL5",
633 " 3100 = Oracle H: Type (Oracle 7+)",
634 " 112 = Oracle S: Type (Oracle 11+)",
635 " 12300 = Oracle T: Type (Oracle 12+)",
636 " 8000 = Sybase ASE",
637 "",
638 "[[ HTTP, SMTP, LDAP Server ]]",
639 "",
640 " 141 = EPiServer 6.x < v4",
641 " 1441 = EPiServer 6.x > v4",
642 " 1600 = Apache $apr1$",
643 " 12600 = ColdFusion 10+",
644 " 1421 = hMailServer",
645 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
646 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
647 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
648 "",
649 "[[ Checksums ]]",
650 "",
651 " 11500 = CRC32",
652 "",
653 "[[ Operating-Systems ]]",
654 "",
655 " 3000 = LM",
656 " 1000 = NTLM",
657 " 1100 = Domain Cached Credentials (DCC), MS Cache",
658 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
659 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
660 " 1500 = descrypt, DES(Unix), Traditional DES",
661 " 12400 = BSDiCrypt, Extended DES",
662 " 500 = md5crypt $1$, MD5(Unix)",
663 " 3200 = bcrypt $2*$, Blowfish(Unix)",
664 " 7400 = sha256crypt $5$, SHA256(Unix)",
665 " 1800 = sha512crypt $6$, SHA512(Unix)",
666 " 122 = OSX v10.4",
667 " 122 = OSX v10.5",
668 " 122 = OSX v10.6",
669 " 1722 = OSX v10.7",
670 " 7100 = OSX v10.8",
671 " 7100 = OSX v10.9",
672 " 7100 = OSX v10.10",
673 " 6300 = AIX {smd5}",
674 " 6700 = AIX {ssha1}",
675 " 6400 = AIX {ssha256}",
676 " 6500 = AIX {ssha512}",
677 " 2400 = Cisco-PIX",
678 " 2410 = Cisco-ASA",
679 " 500 = Cisco-IOS $1$",
680 " 5700 = Cisco-IOS $4$",
681 " 9200 = Cisco-IOS $8$",
682 " 9300 = Cisco-IOS $9$",
683 " 22 = Juniper Netscreen/SSG (ScreenOS)",
684 " 501 = Juniper IVE",
685 " 5800 = Android PIN",
686 " 8100 = Citrix Netscaler",
687 " 8500 = RACF",
688 " 7200 = GRUB 2",
689 " 9900 = Radmin2",
690 " 125 = ArubaOS",
691 "",
692 "[[ Enterprise Application Software (EAS) ]]",
693 "",
694 " 7700 = SAP CODVN B (BCODE)",
695 " 7800 = SAP CODVN F/G (PASSCODE)",
696 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
697 " 8600 = Lotus Notes/Domino 5",
698 " 8700 = Lotus Notes/Domino 6",
699 " 9100 = Lotus Notes/Domino 8",
700 " 133 = PeopleSoft",
701 " 13500 = PeopleSoft Token",
702 "",
703 "[[ Archives ]]",
704 "",
705 " 11600 = 7-Zip",
706 " 12500 = RAR3-hp",
707 " 13000 = RAR5",
708 " 13200 = AxCrypt",
709 " 13300 = AxCrypt in memory SHA1",
710 " 13600 = WinZip",
711 "",
712 "[[ Full-Disk encryptions (FDE) ]]",
713 "",
714 " 62XY = TrueCrypt 5.0+",
715 " X = 1 = PBKDF2-HMAC-RipeMD160",
716 " X = 2 = PBKDF2-HMAC-SHA512",
717 " X = 3 = PBKDF2-HMAC-Whirlpool",
718 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
719 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
720 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
721 " Y = 3 = XTS 1536 bit (Ciphers: All)",
722 " 8800 = Android FDE < v4.3",
723 " 12900 = Android FDE (Samsung DEK)",
724 " 12200 = eCryptfs",
725 "",
726 "[[ Documents ]]",
727 "",
728 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
729 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
730 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
731 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
732 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
733 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
734 " 9400 = MS Office 2007",
735 " 9500 = MS Office 2010",
736 " 9600 = MS Office 2013",
737 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
738 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
739 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
740 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
741 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
742 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
743 "",
744 "[[ Password Managers ]]",
745 "",
746 " 9000 = Password Safe v2",
747 " 5200 = Password Safe v3",
748 " 6800 = Lastpass",
749 " 6600 = 1Password, agilekeychain",
750 " 8200 = 1Password, cloudkeychain",
751 " 11300 = Bitcoin/Litecoin wallet.dat",
752 " 12700 = Blockchain, My Wallet",
753 " 13400 = Keepass 1 (AES/Twofish) and Keepass 2 (AES)",
754 "",
755 NULL
756 };
757
758 /**
759 * hashcat specific functions
760 */
761
762 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
763 {
764 int exec_pos = (int) device_param->exec_pos - last_num_entries;
765
766 if (exec_pos < 0) exec_pos += EXEC_CACHE;
767
768 double exec_ms_sum = 0;
769
770 int exec_ms_cnt = 0;
771
772 for (int i = 0; i < last_num_entries; i++)
773 {
774 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
775
776 if (exec_ms)
777 {
778 exec_ms_sum += exec_ms;
779
780 exec_ms_cnt++;
781 }
782 }
783
784 if (exec_ms_cnt == 0) return 0;
785
786 return exec_ms_sum / exec_ms_cnt;
787 }
788
789 void status_display_automat ()
790 {
791 FILE *out = stdout;
792
793 fprintf (out, "STATUS\t%u\t", data.devices_status);
794
795 /**
796 * speed new
797 */
798
799 fprintf (out, "SPEED\t");
800
801 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
802 {
803 hc_device_param_t *device_param = &data.devices_param[device_id];
804
805 if (device_param->skipped) continue;
806
807 u64 speed_cnt = 0;
808 double speed_ms = 0;
809
810 for (int i = 0; i < SPEED_CACHE; i++)
811 {
812 speed_cnt += device_param->speed_cnt[i];
813 speed_ms += device_param->speed_ms[i];
814 }
815
816 speed_cnt /= SPEED_CACHE;
817 speed_ms /= SPEED_CACHE;
818
819 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
820 }
821
822 /**
823 * exec time
824 */
825
826 fprintf (out, "EXEC_RUNTIME\t");
827
828 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
829 {
830 hc_device_param_t *device_param = &data.devices_param[device_id];
831
832 if (device_param->skipped) continue;
833
834 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
835
836 fprintf (out, "%f\t", exec_ms_avg);
837 }
838
839 /**
840 * words_cur
841 */
842
843 u64 words_cur = get_lowest_words_done ();
844
845 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
846
847 /**
848 * counter
849 */
850
851 u64 progress_total = data.words_cnt * data.salts_cnt;
852
853 u64 all_done = 0;
854 u64 all_rejected = 0;
855 u64 all_restored = 0;
856
857 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
858 {
859 all_done += data.words_progress_done[salt_pos];
860 all_rejected += data.words_progress_rejected[salt_pos];
861 all_restored += data.words_progress_restored[salt_pos];
862 }
863
864 u64 progress_cur = all_restored + all_done + all_rejected;
865 u64 progress_end = progress_total;
866
867 u64 progress_skip = 0;
868
869 if (data.skip)
870 {
871 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
872
873 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
874 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
875 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
876 }
877
878 if (data.limit)
879 {
880 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
881
882 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
883 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
884 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
885 }
886
887 u64 progress_cur_relative_skip = progress_cur - progress_skip;
888 u64 progress_end_relative_skip = progress_end - progress_skip;
889
890 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
891
892 /**
893 * cracks
894 */
895
896 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
897 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
898
899 /**
900 * temperature
901 */
902
903 #ifdef HAVE_HWMON
904 if (data.gpu_temp_disable == 0)
905 {
906 fprintf (out, "TEMP\t");
907
908 hc_thread_mutex_lock (mux_adl);
909
910 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
911 {
912 hc_device_param_t *device_param = &data.devices_param[device_id];
913
914 if (device_param->skipped) continue;
915
916 int temp = hm_get_temperature_with_device_id (device_id);
917
918 fprintf (out, "%d\t", temp);
919 }
920
921 hc_thread_mutex_unlock (mux_adl);
922 }
923 #endif // HAVE_HWMON
924
925 /**
926 * flush
927 */
928
929 #ifdef _WIN
930 fputc ('\r', out);
931 fputc ('\n', out);
932 #endif
933
934 #ifdef _POSIX
935 fputc ('\n', out);
936 #endif
937
938 fflush (out);
939 }
940
941 void status_display ()
942 {
943 if (data.devices_status == STATUS_INIT) return;
944 if (data.devices_status == STATUS_STARTING) return;
945 if (data.devices_status == STATUS_BYPASS) return;
946
947 if (data.status_automat == 1)
948 {
949 status_display_automat ();
950
951 return;
952 }
953
954 char tmp_buf[1000] = { 0 };
955
956 uint tmp_len = 0;
957
958 log_info ("Session.Name...: %s", data.session);
959
960 char *status_type = strstatus (data.devices_status);
961
962 uint hash_mode = data.hash_mode;
963
964 char *hash_type = strhashtype (hash_mode); // not a bug
965
966 log_info ("Status.........: %s", status_type);
967
968 /**
969 * show rules
970 */
971
972 if (data.rp_files_cnt)
973 {
974 uint i;
975
976 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
977 {
978 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
979 }
980
981 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
982
983 log_info ("Rules.Type.....: %s", tmp_buf);
984
985 tmp_len = 0;
986 }
987
988 if (data.rp_gen)
989 {
990 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
991
992 if (data.rp_gen_seed)
993 {
994 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
995 }
996 }
997
998 /**
999 * show input
1000 */
1001
1002 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1003 {
1004 if (data.wordlist_mode == WL_MODE_FILE)
1005 {
1006 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
1007 }
1008 else if (data.wordlist_mode == WL_MODE_STDIN)
1009 {
1010 log_info ("Input.Mode.....: Pipe");
1011 }
1012 }
1013 else if (data.attack_mode == ATTACK_MODE_COMBI)
1014 {
1015 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1016 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1017 }
1018 else if (data.attack_mode == ATTACK_MODE_BF)
1019 {
1020 char *mask = data.mask;
1021
1022 if (mask != NULL)
1023 {
1024 uint mask_len = data.css_cnt;
1025
1026 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1027
1028 if (mask_len > 0)
1029 {
1030 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1031 {
1032 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1033 {
1034 mask_len -= data.salts_buf[0].salt_len;
1035 }
1036 }
1037
1038 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1039
1040 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1041 }
1042
1043 if (data.maskcnt > 1)
1044 {
1045 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1046
1047 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1048 }
1049
1050 log_info ("Input.Mode.....: %s", tmp_buf);
1051 }
1052
1053 tmp_len = 0;
1054 }
1055 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1056 {
1057 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1058 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1059 }
1060 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1061 {
1062 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1063 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1064 }
1065
1066 if (data.digests_cnt == 1)
1067 {
1068 if (data.hash_mode == 2500)
1069 {
1070 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1071
1072 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1073 (char *) data.salts_buf[0].salt_buf,
1074 wpa->orig_mac1[0],
1075 wpa->orig_mac1[1],
1076 wpa->orig_mac1[2],
1077 wpa->orig_mac1[3],
1078 wpa->orig_mac1[4],
1079 wpa->orig_mac1[5],
1080 wpa->orig_mac2[0],
1081 wpa->orig_mac2[1],
1082 wpa->orig_mac2[2],
1083 wpa->orig_mac2[3],
1084 wpa->orig_mac2[4],
1085 wpa->orig_mac2[5]);
1086 }
1087 else if (data.hash_mode == 5200)
1088 {
1089 log_info ("Hash.Target....: File (%s)", data.hashfile);
1090 }
1091 else if (data.hash_mode == 9000)
1092 {
1093 log_info ("Hash.Target....: File (%s)", data.hashfile);
1094 }
1095 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1096 {
1097 log_info ("Hash.Target....: File (%s)", data.hashfile);
1098 }
1099 else
1100 {
1101 char out_buf[HCBUFSIZ] = { 0 };
1102
1103 ascii_digest (out_buf, 0, 0);
1104
1105 // limit length
1106 if (strlen (out_buf) > 40)
1107 {
1108 out_buf[41] = '.';
1109 out_buf[42] = '.';
1110 out_buf[43] = '.';
1111 out_buf[44] = 0;
1112 }
1113
1114 log_info ("Hash.Target....: %s", out_buf);
1115 }
1116 }
1117 else
1118 {
1119 if (data.hash_mode == 3000)
1120 {
1121 char out_buf1[32] = { 0 };
1122 char out_buf2[32] = { 0 };
1123
1124 ascii_digest (out_buf1, 0, 0);
1125 ascii_digest (out_buf2, 0, 1);
1126
1127 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1128 }
1129 else
1130 {
1131 log_info ("Hash.Target....: File (%s)", data.hashfile);
1132 }
1133 }
1134
1135 log_info ("Hash.Type......: %s", hash_type);
1136
1137 /**
1138 * speed new
1139 */
1140
1141 u64 speed_cnt[DEVICES_MAX] = { 0 };
1142 double speed_ms[DEVICES_MAX] = { 0 };
1143
1144 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1145 {
1146 hc_device_param_t *device_param = &data.devices_param[device_id];
1147
1148 if (device_param->skipped) continue;
1149
1150 speed_cnt[device_id] = 0;
1151 speed_ms[device_id] = 0;
1152
1153 for (int i = 0; i < SPEED_CACHE; i++)
1154 {
1155 speed_cnt[device_id] += device_param->speed_cnt[i];
1156 speed_ms[device_id] += device_param->speed_ms[i];
1157 }
1158
1159 speed_cnt[device_id] /= SPEED_CACHE;
1160 speed_ms[device_id] /= SPEED_CACHE;
1161 }
1162
1163 float hashes_all_ms = 0;
1164
1165 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1166
1167 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1168 {
1169 hc_device_param_t *device_param = &data.devices_param[device_id];
1170
1171 if (device_param->skipped) continue;
1172
1173 hashes_dev_ms[device_id] = 0;
1174
1175 if (speed_ms[device_id])
1176 {
1177 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1178
1179 hashes_all_ms += hashes_dev_ms[device_id];
1180 }
1181 }
1182
1183 /**
1184 * exec time
1185 */
1186
1187 double exec_all_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 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1196
1197 exec_all_ms[device_id] = exec_ms_avg;
1198 }
1199
1200 /**
1201 * timers
1202 */
1203
1204 double ms_running = 0;
1205
1206 hc_timer_get (data.timer_running, ms_running);
1207
1208 double ms_paused = data.ms_paused;
1209
1210 if (data.devices_status == STATUS_PAUSED)
1211 {
1212 double ms_paused_tmp = 0;
1213
1214 hc_timer_get (data.timer_paused, ms_paused_tmp);
1215
1216 ms_paused += ms_paused_tmp;
1217 }
1218
1219 #ifdef WIN
1220
1221 __time64_t sec_run = ms_running / 1000;
1222
1223 #else
1224
1225 time_t sec_run = ms_running / 1000;
1226
1227 #endif
1228
1229 if (sec_run)
1230 {
1231 char display_run[32] = { 0 };
1232
1233 struct tm tm_run;
1234
1235 struct tm *tmp = NULL;
1236
1237 #ifdef WIN
1238
1239 tmp = _gmtime64 (&sec_run);
1240
1241 #else
1242
1243 tmp = gmtime (&sec_run);
1244
1245 #endif
1246
1247 if (tmp != NULL)
1248 {
1249 memset (&tm_run, 0, sizeof (tm_run));
1250
1251 memcpy (&tm_run, tmp, sizeof (tm_run));
1252
1253 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1254
1255 char *start = ctime (&data.proc_start);
1256
1257 size_t start_len = strlen (start);
1258
1259 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1260 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1261
1262 log_info ("Time.Started...: %s (%s)", start, display_run);
1263 }
1264 }
1265 else
1266 {
1267 log_info ("Time.Started...: 0 secs");
1268 }
1269
1270 /**
1271 * counters
1272 */
1273
1274 u64 progress_total = data.words_cnt * data.salts_cnt;
1275
1276 u64 all_done = 0;
1277 u64 all_rejected = 0;
1278 u64 all_restored = 0;
1279
1280 u64 progress_noneed = 0;
1281
1282 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1283 {
1284 all_done += data.words_progress_done[salt_pos];
1285 all_rejected += data.words_progress_rejected[salt_pos];
1286 all_restored += data.words_progress_restored[salt_pos];
1287
1288 // Important for ETA only
1289
1290 if (data.salts_shown[salt_pos] == 1)
1291 {
1292 const u64 all = data.words_progress_done[salt_pos]
1293 + data.words_progress_rejected[salt_pos]
1294 + data.words_progress_restored[salt_pos];
1295
1296 const u64 left = data.words_cnt - all;
1297
1298 progress_noneed += left;
1299 }
1300 }
1301
1302 u64 progress_cur = all_restored + all_done + all_rejected;
1303 u64 progress_end = progress_total;
1304
1305 u64 progress_skip = 0;
1306
1307 if (data.skip)
1308 {
1309 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1310
1311 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1312 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1313 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1314 }
1315
1316 if (data.limit)
1317 {
1318 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1319
1320 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1321 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1322 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1323 }
1324
1325 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1326 u64 progress_end_relative_skip = progress_end - progress_skip;
1327
1328 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1329 {
1330 if (data.devices_status != STATUS_CRACKED)
1331 {
1332 #ifdef WIN
1333 __time64_t sec_etc = 0;
1334 #else
1335 time_t sec_etc = 0;
1336 #endif
1337
1338 if (hashes_all_ms)
1339 {
1340 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1341
1342 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1343
1344 sec_etc = ms_left / 1000;
1345 }
1346
1347 if (sec_etc == 0)
1348 {
1349 //log_info ("Time.Estimated.: 0 secs");
1350 }
1351 else if ((u64) sec_etc > ETC_MAX)
1352 {
1353 log_info ("Time.Estimated.: > 10 Years");
1354 }
1355 else
1356 {
1357 char display_etc[32] = { 0 };
1358
1359 struct tm tm_etc;
1360
1361 struct tm *tmp = NULL;
1362
1363 #ifdef WIN
1364
1365 tmp = _gmtime64 (&sec_etc);
1366
1367 #else
1368
1369 tmp = gmtime (&sec_etc);
1370
1371 #endif
1372
1373 if (tmp != NULL)
1374 {
1375 memset (&tm_etc, 0, sizeof (tm_etc));
1376
1377 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1378
1379 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1380
1381 time_t now;
1382
1383 time (&now);
1384
1385 now += sec_etc;
1386
1387 char *etc = ctime (&now);
1388
1389 size_t etc_len = strlen (etc);
1390
1391 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1392 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1393
1394 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1395 }
1396 }
1397 }
1398 }
1399
1400 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1401 {
1402 hc_device_param_t *device_param = &data.devices_param[device_id];
1403
1404 if (device_param->skipped) continue;
1405
1406 char display_dev_cur[16] = { 0 };
1407
1408 strncpy (display_dev_cur, "0.00", 4);
1409
1410 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1411
1412 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1413 }
1414
1415 char display_all_cur[16] = { 0 };
1416
1417 strncpy (display_all_cur, "0.00", 4);
1418
1419 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1420
1421 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1422
1423 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1424 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1425
1426 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);
1427
1428 // crack-per-time
1429
1430 if (data.digests_cnt > 100)
1431 {
1432 time_t now = time (NULL);
1433
1434 int cpt_cur_min = 0;
1435 int cpt_cur_hour = 0;
1436 int cpt_cur_day = 0;
1437
1438 for (int i = 0; i < CPT_BUF; i++)
1439 {
1440 const uint cracked = data.cpt_buf[i].cracked;
1441 const time_t timestamp = data.cpt_buf[i].timestamp;
1442
1443 if ((timestamp + 60) > now)
1444 {
1445 cpt_cur_min += cracked;
1446 }
1447
1448 if ((timestamp + 3600) > now)
1449 {
1450 cpt_cur_hour += cracked;
1451 }
1452
1453 if ((timestamp + 86400) > now)
1454 {
1455 cpt_cur_day += cracked;
1456 }
1457 }
1458
1459 double ms_real = ms_running - ms_paused;
1460
1461 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1462 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1463 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1464
1465 if ((data.cpt_start + 86400) < now)
1466 {
1467 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1468 cpt_cur_min,
1469 cpt_cur_hour,
1470 cpt_cur_day,
1471 cpt_avg_min,
1472 cpt_avg_hour,
1473 cpt_avg_day);
1474 }
1475 else if ((data.cpt_start + 3600) < now)
1476 {
1477 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1478 cpt_cur_min,
1479 cpt_cur_hour,
1480 cpt_avg_min,
1481 cpt_avg_hour,
1482 cpt_avg_day);
1483 }
1484 else if ((data.cpt_start + 60) < now)
1485 {
1486 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1487 cpt_cur_min,
1488 cpt_avg_min,
1489 cpt_avg_hour,
1490 cpt_avg_day);
1491 }
1492 else
1493 {
1494 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1495 cpt_avg_min,
1496 cpt_avg_hour,
1497 cpt_avg_day);
1498 }
1499 }
1500
1501 // Restore point
1502
1503 u64 restore_point = get_lowest_words_done ();
1504
1505 u64 restore_total = data.words_base;
1506
1507 float percent_restore = 0;
1508
1509 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1510
1511 if (progress_end_relative_skip)
1512 {
1513 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1514 {
1515 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1516 float percent_rejected = 0.0;
1517
1518 if (progress_cur)
1519 {
1520 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1521 }
1522
1523 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);
1524 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1525
1526 if (data.restore_disable == 0)
1527 {
1528 if (percent_finished != 1)
1529 {
1530 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1531 }
1532 }
1533 }
1534 }
1535 else
1536 {
1537 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1538 {
1539 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1540 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1541
1542 if (data.restore_disable == 0)
1543 {
1544 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1545 }
1546 }
1547 else
1548 {
1549 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1550 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1551
1552 // --restore not allowed if stdin is used -- really? why?
1553
1554 //if (data.restore_disable == 0)
1555 //{
1556 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1557 //}
1558 }
1559 }
1560
1561 #ifdef HAVE_HWMON
1562 if (data.gpu_temp_disable == 0)
1563 {
1564 hc_thread_mutex_lock (mux_adl);
1565
1566 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1567 {
1568 hc_device_param_t *device_param = &data.devices_param[device_id];
1569
1570 if (device_param->skipped) continue;
1571
1572 #define HM_STR_BUF_SIZE 255
1573
1574 if (data.hm_device[device_id].fan_supported == 1)
1575 {
1576 char utilization[HM_STR_BUF_SIZE] = { 0 };
1577 char temperature[HM_STR_BUF_SIZE] = { 0 };
1578 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1579
1580 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1581 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1582
1583 if (device_param->vendor_id == VENDOR_ID_AMD)
1584 {
1585 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1586 }
1587 else if (device_param->vendor_id == VENDOR_ID_NV)
1588 {
1589 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1590 }
1591
1592 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1593 }
1594 else
1595 {
1596 char utilization[HM_STR_BUF_SIZE] = { 0 };
1597 char temperature[HM_STR_BUF_SIZE] = { 0 };
1598
1599 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1600 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1601
1602 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1603 }
1604 }
1605
1606 hc_thread_mutex_unlock (mux_adl);
1607 }
1608 #endif // HAVE_HWMON
1609 }
1610
1611 static void status_benchmark ()
1612 {
1613 if (data.devices_status == STATUS_INIT) return;
1614 if (data.devices_status == STATUS_STARTING) return;
1615
1616 if (data.words_cnt == 0) return;
1617
1618 u64 speed_cnt[DEVICES_MAX] = { 0 };
1619 double speed_ms[DEVICES_MAX] = { 0 };
1620
1621 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1622 {
1623 hc_device_param_t *device_param = &data.devices_param[device_id];
1624
1625 if (device_param->skipped) continue;
1626
1627 speed_cnt[device_id] = device_param->speed_cnt[0];
1628 speed_ms[device_id] = device_param->speed_ms[0];
1629 }
1630
1631 float hashes_all_ms = 0;
1632
1633 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1634
1635 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1636 {
1637 hc_device_param_t *device_param = &data.devices_param[device_id];
1638
1639 if (device_param->skipped) continue;
1640
1641 hashes_dev_ms[device_id] = 0;
1642
1643 if (speed_ms[device_id])
1644 {
1645 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1646
1647 hashes_all_ms += hashes_dev_ms[device_id];
1648 }
1649 }
1650
1651 /**
1652 * exec time
1653 */
1654
1655 double exec_all_ms[DEVICES_MAX] = { 0 };
1656
1657 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1658 {
1659 hc_device_param_t *device_param = &data.devices_param[device_id];
1660
1661 if (device_param->skipped) continue;
1662
1663 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1664
1665 exec_all_ms[device_id] = exec_ms_avg;
1666 }
1667
1668 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1669 {
1670 hc_device_param_t *device_param = &data.devices_param[device_id];
1671
1672 if (device_param->skipped) continue;
1673
1674 char display_dev_cur[16] = { 0 };
1675
1676 strncpy (display_dev_cur, "0.00", 4);
1677
1678 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1679
1680 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1681 }
1682
1683 char display_all_cur[16] = { 0 };
1684
1685 strncpy (display_all_cur, "0.00", 4);
1686
1687 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1688
1689 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1690 }
1691
1692 /**
1693 * hashcat -only- functions
1694 */
1695
1696 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1697 {
1698 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1699 {
1700 if (attack_kern == ATTACK_KERN_STRAIGHT)
1701 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1702 else if (attack_kern == ATTACK_KERN_COMBI)
1703 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1704 else if (attack_kern == ATTACK_KERN_BF)
1705 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1706 }
1707 else
1708 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1709 }
1710
1711 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)
1712 {
1713 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1714 {
1715 if (attack_kern == ATTACK_KERN_STRAIGHT)
1716 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1717 else if (attack_kern == ATTACK_KERN_COMBI)
1718 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1719 else if (attack_kern == ATTACK_KERN_BF)
1720 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1721 }
1722 else
1723 {
1724 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1725 }
1726 }
1727
1728 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1729 {
1730 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1731 {
1732 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1733 }
1734 else
1735 {
1736 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1737 }
1738 }
1739
1740 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)
1741 {
1742 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1743 {
1744 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1745 }
1746 else
1747 {
1748 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1749 }
1750 }
1751
1752 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1753 {
1754 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1755 }
1756
1757 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1758 {
1759 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1760 }
1761
1762 static uint convert_from_hex (char *line_buf, const uint line_len)
1763 {
1764 if (line_len & 1) return (line_len); // not in hex
1765
1766 if (data.hex_wordlist == 1)
1767 {
1768 uint i;
1769 uint j;
1770
1771 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1772 {
1773 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1774 }
1775
1776 memset (line_buf + i, 0, line_len - i);
1777
1778 return (i);
1779 }
1780 else if (line_len >= 6) // $HEX[] = 6
1781 {
1782 if (line_buf[0] != '$') return (line_len);
1783 if (line_buf[1] != 'H') return (line_len);
1784 if (line_buf[2] != 'E') return (line_len);
1785 if (line_buf[3] != 'X') return (line_len);
1786 if (line_buf[4] != '[') return (line_len);
1787 if (line_buf[line_len - 1] != ']') return (line_len);
1788
1789 uint i;
1790 uint j;
1791
1792 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1793 {
1794 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1795 }
1796
1797 memset (line_buf + i, 0, line_len - i);
1798
1799 return (i);
1800 }
1801
1802 return (line_len);
1803 }
1804
1805 static void clear_prompt ()
1806 {
1807 fputc ('\r', stdout);
1808
1809 for (size_t i = 0; i < strlen (PROMPT); i++)
1810 {
1811 fputc (' ', stdout);
1812 }
1813
1814 fputc ('\r', stdout);
1815
1816 fflush (stdout);
1817 }
1818
1819 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1820 {
1821 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);
1822 }
1823
1824 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1825 {
1826 char *outfile = data.outfile;
1827 uint quiet = data.quiet;
1828 FILE *pot_fp = data.pot_fp;
1829 uint loopback = data.loopback;
1830 uint debug_mode = data.debug_mode;
1831 char *debug_file = data.debug_file;
1832
1833 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1834 int debug_rule_len = 0; // -1 error
1835 uint debug_plain_len = 0;
1836
1837 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1838
1839 // hash
1840
1841 char out_buf[HCBUFSIZ] = { 0 };
1842
1843 ascii_digest (out_buf, salt_pos, digest_pos);
1844
1845 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1846
1847 // plain
1848
1849 plain_t plain;
1850
1851 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);
1852
1853 uint gidvid = plain.gidvid;
1854 uint il_pos = plain.il_pos;
1855
1856 u64 crackpos = device_param->words_off;
1857
1858 uint plain_buf[16] = { 0 };
1859
1860 u8 *plain_ptr = (u8 *) plain_buf;
1861 unsigned int plain_len = 0;
1862
1863 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1864 {
1865 u64 gidd = gidvid;
1866 u64 gidm = 0;
1867
1868 pw_t pw;
1869
1870 gidd_to_pw_t (device_param, gidd, &pw);
1871
1872 for (int i = 0, j = gidm; i < 16; i++, j++)
1873 {
1874 plain_buf[i] = pw.i[j];
1875 }
1876
1877 plain_len = pw.pw_len;
1878
1879 const uint off = device_param->innerloop_pos + il_pos;
1880
1881 if (debug_mode > 0)
1882 {
1883 debug_rule_len = 0;
1884
1885 // save rule
1886 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1887 {
1888 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1889
1890 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1891 }
1892
1893 // save plain
1894 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1895 {
1896 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1897
1898 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1899
1900 debug_plain_len = plain_len;
1901 }
1902 }
1903
1904 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1905
1906 crackpos += gidvid;
1907 crackpos *= data.kernel_rules_cnt;
1908 crackpos += device_param->innerloop_pos + il_pos;
1909
1910 if (plain_len > data.pw_max) plain_len = data.pw_max;
1911 }
1912 else if (data.attack_mode == ATTACK_MODE_COMBI)
1913 {
1914 u64 gidd = gidvid;
1915 u64 gidm = 0;
1916
1917 pw_t pw;
1918
1919 gidd_to_pw_t (device_param, gidd, &pw);
1920
1921 for (int i = 0, j = gidm; i < 16; i++, j++)
1922 {
1923 plain_buf[i] = pw.i[j];
1924 }
1925
1926 plain_len = pw.pw_len;
1927
1928 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1929 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1930
1931 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1932 {
1933 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1934 }
1935 else
1936 {
1937 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1938
1939 memcpy (plain_ptr, comb_buf, comb_len);
1940 }
1941
1942 plain_len += comb_len;
1943
1944 crackpos += gidvid;
1945 crackpos *= data.combs_cnt;
1946 crackpos += device_param->innerloop_pos + il_pos;
1947
1948 if (data.pw_max != PW_DICTMAX1)
1949 {
1950 if (plain_len > data.pw_max) plain_len = data.pw_max;
1951 }
1952 }
1953 else if (data.attack_mode == ATTACK_MODE_BF)
1954 {
1955 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1956 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1957
1958 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1959 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1960
1961 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1962 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1963
1964 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1965 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1966
1967 plain_len = data.css_cnt;
1968
1969 crackpos += gidvid;
1970 crackpos *= data.bfs_cnt;
1971 crackpos += device_param->innerloop_pos + il_pos;
1972 }
1973 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1974 {
1975 u64 gidd = gidvid;
1976 u64 gidm = 0;
1977
1978 pw_t pw;
1979
1980 gidd_to_pw_t (device_param, gidd, &pw);
1981
1982 for (int i = 0, j = gidm; i < 16; i++, j++)
1983 {
1984 plain_buf[i] = pw.i[j];
1985 }
1986
1987 plain_len = pw.pw_len;
1988
1989 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
1990
1991 uint start = 0;
1992 uint stop = device_param->kernel_params_mp_buf32[4];
1993
1994 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
1995
1996 plain_len += start + stop;
1997
1998 crackpos += gidvid;
1999 crackpos *= data.combs_cnt;
2000 crackpos += device_param->innerloop_pos + il_pos;
2001
2002 if (data.pw_max != PW_DICTMAX1)
2003 {
2004 if (plain_len > data.pw_max) plain_len = data.pw_max;
2005 }
2006 }
2007 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2008 {
2009 u64 gidd = gidvid;
2010 u64 gidm = 0;
2011
2012 pw_t pw;
2013
2014 gidd_to_pw_t (device_param, gidd, &pw);
2015
2016 for (int i = 0, j = gidm; i < 16; i++, j++)
2017 {
2018 plain_buf[i] = pw.i[j];
2019 }
2020
2021 plain_len = pw.pw_len;
2022
2023 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2024
2025 uint start = 0;
2026 uint stop = device_param->kernel_params_mp_buf32[4];
2027
2028 memmove (plain_ptr + stop, plain_ptr, plain_len);
2029
2030 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2031
2032 plain_len += start + stop;
2033
2034 crackpos += gidvid;
2035 crackpos *= data.combs_cnt;
2036 crackpos += device_param->innerloop_pos + il_pos;
2037
2038 if (data.pw_max != PW_DICTMAX1)
2039 {
2040 if (plain_len > data.pw_max) plain_len = data.pw_max;
2041 }
2042 }
2043
2044 if (data.attack_mode == ATTACK_MODE_BF)
2045 {
2046 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2047 {
2048 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2049 {
2050 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2051 {
2052 plain_len = plain_len - data.salts_buf[0].salt_len;
2053 }
2054 }
2055
2056 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2057 {
2058 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2059 {
2060 plain_ptr[j] = plain_ptr[i];
2061 }
2062
2063 plain_len = plain_len / 2;
2064 }
2065 }
2066 }
2067
2068 // if enabled, update also the potfile
2069
2070 if (pot_fp)
2071 {
2072 lock_file (pot_fp);
2073
2074 fprintf (pot_fp, "%s:", out_buf);
2075
2076 format_plain (pot_fp, plain_ptr, plain_len, 1);
2077
2078 fputc ('\n', pot_fp);
2079
2080 fflush (pot_fp);
2081
2082 unlock_file (pot_fp);
2083 }
2084
2085 // outfile
2086
2087 FILE *out_fp = NULL;
2088
2089 if (outfile != NULL)
2090 {
2091 if ((out_fp = fopen (outfile, "ab")) == NULL)
2092 {
2093 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2094
2095 out_fp = stdout;
2096 }
2097 lock_file (out_fp);
2098 }
2099 else
2100 {
2101 out_fp = stdout;
2102
2103 if (quiet == 0) clear_prompt ();
2104 }
2105
2106 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2107
2108 if (outfile != NULL)
2109 {
2110 if (out_fp != stdout)
2111 {
2112 fclose (out_fp);
2113 }
2114 }
2115 else
2116 {
2117 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2118 {
2119 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2120 {
2121 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2122 if (quiet == 0) fflush (stdout);
2123 }
2124 }
2125 }
2126
2127 // loopback
2128
2129 if (loopback)
2130 {
2131 char *loopback_file = data.loopback_file;
2132
2133 FILE *fb_fp = NULL;
2134
2135 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2136 {
2137 lock_file (fb_fp);
2138
2139 format_plain (fb_fp, plain_ptr, plain_len, 1);
2140
2141 fputc ('\n', fb_fp);
2142
2143 fclose (fb_fp);
2144 }
2145 }
2146
2147 // (rule) debug mode
2148
2149 // the next check implies that:
2150 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2151 // - debug_mode > 0
2152
2153 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2154 {
2155 if (debug_rule_len < 0) debug_rule_len = 0;
2156
2157 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2158
2159 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2160
2161 if ((quiet == 0) && (debug_file == NULL))
2162 {
2163 fprintf (stdout, "%s", PROMPT);
2164
2165 fflush (stdout);
2166 }
2167 }
2168 }
2169
2170 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2171 {
2172 salt_t *salt_buf = &data.salts_buf[salt_pos];
2173
2174 int found = 0;
2175
2176 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);
2177
2178 for (uint i = 0; i < device_param->kernel_threads; i++) if (device_param->result[i] == 1) found = 1;
2179
2180 if (found == 1)
2181 {
2182 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2183
2184 log_info_nn ("");
2185
2186 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);
2187
2188 uint cpt_cracked = 0;
2189
2190 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2191 {
2192 uint idx = salt_buf->digests_offset + digest_pos;
2193
2194 if (data.digests_shown_tmp[idx] == 0) continue;
2195
2196 if (data.digests_shown[idx] == 1) continue;
2197
2198 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2199 {
2200 data.digests_shown[idx] = 1;
2201
2202 data.digests_done++;
2203
2204 cpt_cracked++;
2205
2206 salt_buf->digests_done++;
2207
2208 if (salt_buf->digests_done == salt_buf->digests_cnt)
2209 {
2210 data.salts_shown[salt_pos] = 1;
2211
2212 data.salts_done++;
2213 }
2214 }
2215
2216 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2217
2218 check_hash (device_param, salt_pos, digest_pos);
2219 }
2220
2221 if (cpt_cracked > 0)
2222 {
2223 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2224 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2225
2226 data.cpt_pos++;
2227
2228 data.cpt_total += cpt_cracked;
2229
2230 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2231 }
2232
2233 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2234 {
2235 // we need to reset cracked state on the device
2236 // otherwise host thinks again and again the hash was cracked
2237 // and returns invalid password each time
2238
2239 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2240
2241 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);
2242 }
2243
2244 memset (device_param->result, 0, device_param->size_results);
2245
2246 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);
2247 }
2248 }
2249
2250 static void save_hash ()
2251 {
2252 char *hashfile = data.hashfile;
2253
2254 char new_hashfile[256] = { 0 };
2255 char old_hashfile[256] = { 0 };
2256
2257 snprintf (new_hashfile, 255, "%s.new", hashfile);
2258 snprintf (old_hashfile, 255, "%s.old", hashfile);
2259
2260 unlink (new_hashfile);
2261
2262 char separator = data.separator;
2263
2264 FILE *fp = fopen (new_hashfile, "wb");
2265
2266 if (fp == NULL)
2267 {
2268 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2269
2270 exit (-1);
2271 }
2272
2273 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2274 {
2275 if (data.salts_shown[salt_pos] == 1) continue;
2276
2277 salt_t *salt_buf = &data.salts_buf[salt_pos];
2278
2279 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2280 {
2281 uint idx = salt_buf->digests_offset + digest_pos;
2282
2283 if (data.digests_shown[idx] == 1) continue;
2284
2285 if (data.hash_mode != 2500)
2286 {
2287 char out_buf[HCBUFSIZ] = { 0 };
2288
2289 if (data.username == 1)
2290 {
2291 user_t *user = data.hash_info[idx]->user;
2292
2293 uint i;
2294
2295 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2296
2297 fputc (separator, fp);
2298 }
2299
2300 ascii_digest (out_buf, salt_pos, digest_pos);
2301
2302 fputs (out_buf, fp);
2303
2304 log_out (fp, "");
2305 }
2306 else
2307 {
2308 hccap_t hccap;
2309
2310 to_hccap_t (&hccap, salt_pos, digest_pos);
2311
2312 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2313 }
2314 }
2315 }
2316
2317 fflush (fp);
2318
2319 fclose (fp);
2320
2321 unlink (old_hashfile);
2322
2323 if (rename (hashfile, old_hashfile) != 0)
2324 {
2325 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2326
2327 exit (-1);
2328 }
2329
2330 unlink (hashfile);
2331
2332 if (rename (new_hashfile, hashfile) != 0)
2333 {
2334 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2335
2336 exit (-1);
2337 }
2338
2339 unlink (old_hashfile);
2340 }
2341
2342 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2343 {
2344 // function called only in case kernel_power_all > words_left
2345
2346 float kernel_power_div = (float) (total_left) / kernel_power_all;
2347
2348 kernel_power_div += kernel_power_div / 100;
2349
2350 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2351
2352 while (kernel_power_new < total_left)
2353 {
2354 kernel_power_div += kernel_power_div / 100;
2355
2356 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2357 }
2358
2359 if (data.quiet == 0)
2360 {
2361 clear_prompt ();
2362
2363 //log_info ("");
2364
2365 log_info ("INFO: approaching final keyspace, workload adjusted");
2366 log_info ("");
2367
2368 fprintf (stdout, "%s", PROMPT);
2369
2370 fflush (stdout);
2371 }
2372
2373 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2374
2375 return kernel_power_div;
2376 }
2377
2378 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2379 {
2380 uint num_elements = num;
2381
2382 device_param->kernel_params_buf32[30] = data.combs_mode;
2383 device_param->kernel_params_buf32[31] = num;
2384
2385 uint kernel_threads = device_param->kernel_threads;
2386
2387 while (num_elements % kernel_threads) num_elements++;
2388
2389 cl_kernel kernel = NULL;
2390
2391 switch (kern_run)
2392 {
2393 case KERN_RUN_1: kernel = device_param->kernel1; break;
2394 case KERN_RUN_12: kernel = device_param->kernel12; break;
2395 case KERN_RUN_2: kernel = device_param->kernel2; break;
2396 case KERN_RUN_23: kernel = device_param->kernel23; break;
2397 case KERN_RUN_3: kernel = device_param->kernel3; break;
2398 }
2399
2400 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2401 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2402 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2403 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2404 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2405 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2406 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2407 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2408 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2409 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2410 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2411
2412 cl_event event;
2413
2414 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2415 {
2416 const size_t global_work_size[3] = { num_elements, 32, 1 };
2417 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2418
2419 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2420 }
2421 else
2422 {
2423 if (kern_run == KERN_RUN_2)
2424 {
2425 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2426 {
2427 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2428 }
2429 }
2430
2431 while (num_elements % kernel_threads) num_elements++;
2432
2433 const size_t global_work_size[3] = { num_elements, 1, 1 };
2434 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2435
2436 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2437 }
2438
2439 hc_clFlush (data.ocl, device_param->command_queue);
2440
2441 hc_clWaitForEvents (data.ocl, 1, &event);
2442
2443 if (event_update)
2444 {
2445 cl_ulong time_start;
2446 cl_ulong time_end;
2447
2448 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2449 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2450
2451 const double exec_time = (double) (time_end - time_start) / 1000000.0;
2452
2453 uint exec_pos = device_param->exec_pos;
2454
2455 device_param->exec_ms[exec_pos] = exec_time;
2456
2457 exec_pos++;
2458
2459 if (exec_pos == EXEC_CACHE)
2460 {
2461 exec_pos = 0;
2462 }
2463
2464 device_param->exec_pos = exec_pos;
2465 }
2466
2467 hc_clReleaseEvent (data.ocl, event);
2468
2469 hc_clFinish (data.ocl, device_param->command_queue);
2470 }
2471
2472 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2473 {
2474 uint num_elements = num;
2475
2476 switch (kern_run)
2477 {
2478 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2479 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2480 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2481 }
2482
2483 // causes problems with special threads like in bcrypt
2484 // const uint kernel_threads = device_param->kernel_threads;
2485
2486 uint kernel_threads = device_param->kernel_threads;
2487
2488 while (num_elements % kernel_threads) num_elements++;
2489
2490 cl_kernel kernel = NULL;
2491
2492 switch (kern_run)
2493 {
2494 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2495 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2496 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2497 }
2498
2499 switch (kern_run)
2500 {
2501 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2502 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2503 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2504 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2505 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2506 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2507 break;
2508 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2509 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2510 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2511 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2512 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2513 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2514 break;
2515 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2516 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2517 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2518 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2519 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2520 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2521 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2522 break;
2523 }
2524
2525 const size_t global_work_size[3] = { num_elements, 1, 1 };
2526 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2527
2528 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2529
2530 hc_clFlush (data.ocl, device_param->command_queue);
2531
2532 hc_clFinish (data.ocl, device_param->command_queue);
2533 }
2534
2535 static void run_kernel_tm (hc_device_param_t *device_param)
2536 {
2537 const uint num_elements = 1024; // fixed
2538
2539 uint kernel_threads = 32;
2540
2541 cl_kernel kernel = device_param->kernel_tm;
2542
2543 const size_t global_work_size[3] = { num_elements, 1, 1 };
2544 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2545
2546 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2547
2548 hc_clFlush (data.ocl, device_param->command_queue);
2549
2550 hc_clFinish (data.ocl, device_param->command_queue);
2551 }
2552
2553 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2554 {
2555 uint num_elements = num;
2556
2557 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2558 device_param->kernel_params_amp_buf32[6] = num_elements;
2559
2560 // causes problems with special threads like in bcrypt
2561 // const uint kernel_threads = device_param->kernel_threads;
2562
2563 uint kernel_threads = device_param->kernel_threads;
2564
2565 while (num_elements % kernel_threads) num_elements++;
2566
2567 cl_kernel kernel = device_param->kernel_amp;
2568
2569 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2570 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2571
2572 const size_t global_work_size[3] = { num_elements, 1, 1 };
2573 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2574
2575 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2576
2577 hc_clFlush (data.ocl, device_param->command_queue);
2578
2579 hc_clFinish (data.ocl, device_param->command_queue);
2580 }
2581
2582 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2583 {
2584 int rc = -1;
2585
2586 if (device_param->opencl_v12 && device_param->vendor_id == VENDOR_ID_AMD)
2587 {
2588 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2589
2590 const cl_uchar zero = 0;
2591
2592 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2593 }
2594
2595 if (rc != 0)
2596 {
2597 // NOTE: clEnqueueFillBuffer () always fails with -59
2598 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2599 // How's that possible, OpenCL 1.2 support is advertised??
2600 // We need to workaround...
2601
2602 #define FILLSZ 0x100000
2603
2604 char *tmp = (char *) mymalloc (FILLSZ);
2605
2606 for (size_t i = 0; i < size; i += FILLSZ)
2607 {
2608 const size_t left = size - i;
2609
2610 const size_t fillsz = MIN (FILLSZ, left);
2611
2612 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2613 }
2614
2615 myfree (tmp);
2616 }
2617 }
2618
2619 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)
2620 {
2621 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2622 {
2623 if (attack_mode == ATTACK_MODE_BF)
2624 {
2625 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2626 {
2627 const uint size_tm = 32 * sizeof (bs_word_t);
2628
2629 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2630
2631 run_kernel_tm (device_param);
2632
2633 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);
2634 }
2635 }
2636
2637 if (highest_pw_len < 16)
2638 {
2639 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2640 }
2641 else if (highest_pw_len < 32)
2642 {
2643 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2644 }
2645 else
2646 {
2647 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2648 }
2649 }
2650 else
2651 {
2652 run_kernel_amp (device_param, pws_cnt);
2653
2654 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2655
2656 if (opts_type & OPTS_TYPE_HOOK12)
2657 {
2658 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2659 }
2660
2661 uint iter = salt_buf->salt_iter;
2662
2663 uint loop_step = device_param->kernel_loops;
2664
2665 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2666 {
2667 uint loop_left = iter - loop_pos;
2668
2669 loop_left = MIN (loop_left, loop_step);
2670
2671 device_param->kernel_params_buf32[25] = loop_pos;
2672 device_param->kernel_params_buf32[26] = loop_left;
2673
2674 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2675
2676 if (data.devices_status == STATUS_CRACKED) break;
2677 if (data.devices_status == STATUS_ABORTED) break;
2678 if (data.devices_status == STATUS_QUIT) break;
2679
2680 /**
2681 * speed
2682 */
2683
2684 const float iter_part = (float) (loop_pos + loop_left) / iter;
2685
2686 const u64 perf_sum_all = pws_cnt * iter_part;
2687
2688 double speed_ms;
2689
2690 hc_timer_get (device_param->timer_speed, speed_ms);
2691
2692 const u32 speed_pos = device_param->speed_pos;
2693
2694 device_param->speed_cnt[speed_pos] = perf_sum_all;
2695
2696 device_param->speed_ms[speed_pos] = speed_ms;
2697
2698 if (data.benchmark == 1)
2699 {
2700 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
2701 }
2702 }
2703
2704 if (opts_type & OPTS_TYPE_HOOK23)
2705 {
2706 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2707
2708 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);
2709
2710 // do something with data
2711
2712 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);
2713 }
2714
2715 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2716 }
2717 }
2718
2719 static int run_rule_engine (const int rule_len, const char *rule_buf)
2720 {
2721 if (rule_len == 0)
2722 {
2723 return 0;
2724 }
2725 else if (rule_len == 1)
2726 {
2727 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2728 }
2729
2730 return 1;
2731 }
2732
2733 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2734 {
2735 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2736 {
2737 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);
2738 }
2739 else if (data.attack_kern == ATTACK_KERN_COMBI)
2740 {
2741 if (data.attack_mode == ATTACK_MODE_HYBRID2)
2742 {
2743 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2744 {
2745 for (u32 i = 0; i < pws_cnt; i++)
2746 {
2747 const u32 pw_len = device_param->pws_buf[i].pw_len;
2748
2749 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2750
2751 ptr[pw_len] = 0x01;
2752 }
2753 }
2754 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2755 {
2756 for (u32 i = 0; i < pws_cnt; i++)
2757 {
2758 const u32 pw_len = device_param->pws_buf[i].pw_len;
2759
2760 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2761
2762 ptr[pw_len] = 0x80;
2763 }
2764 }
2765 }
2766
2767 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);
2768 }
2769 else if (data.attack_kern == ATTACK_KERN_BF)
2770 {
2771 const u64 off = device_param->words_off;
2772
2773 device_param->kernel_params_mp_l_buf64[3] = off;
2774
2775 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2776 }
2777 }
2778
2779 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
2780 {
2781 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2782
2783 device_param->kernel_params_buf32[25] = 0;
2784 device_param->kernel_params_buf32[26] = kernel_loops; // not a bug, both need to be set
2785 device_param->kernel_params_buf32[27] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
2786
2787 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2788 {
2789 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2790 }
2791 else
2792 {
2793 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2794 }
2795
2796 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
2797
2798 return exec_ms_prev;
2799 }
2800
2801 static void autotune (hc_device_param_t *device_param)
2802 {
2803 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2804
2805 const u32 kernel_accel_min = device_param->kernel_accel_min;
2806 const u32 kernel_accel_max = device_param->kernel_accel_max;
2807
2808 const u32 kernel_loops_min = device_param->kernel_loops_min;
2809 const u32 kernel_loops_max = device_param->kernel_loops_max;
2810
2811 u32 kernel_accel = kernel_accel_min;
2812 u32 kernel_loops = kernel_loops_min;
2813
2814 // init some fake words
2815
2816 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
2817
2818 for (u32 i = 0; i < kernel_power_max; i++)
2819 {
2820 device_param->pws_buf[i].i[0] = i;
2821 device_param->pws_buf[i].i[1] = 0x01234567;
2822 device_param->pws_buf[i].pw_len = 7;
2823 }
2824
2825 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, kernel_power_max * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2826
2827 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2828 {
2829 run_kernel_amp (device_param, kernel_power_max);
2830 }
2831
2832 // begin actual testing
2833
2834 double exec_ms_final = try_run (device_param, kernel_accel, kernel_loops);
2835
2836 if ((kernel_loops_min == kernel_loops_max) || (kernel_accel_min == kernel_accel_max))
2837 {
2838 // we do this in case the user specified a fixed -u and -n on the commandline
2839 // so we have a cached kernel for benchmark
2840
2841 try_run (device_param, kernel_accel, kernel_loops);
2842 try_run (device_param, kernel_accel, kernel_loops);
2843 try_run (device_param, kernel_accel, kernel_loops);
2844 try_run (device_param, kernel_accel, kernel_loops);
2845 try_run (device_param, kernel_accel, kernel_loops);
2846 }
2847
2848 // first find out highest kernel-loops that stays below target_ms
2849
2850 #define STEPS_CNT 10
2851
2852 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
2853 {
2854 double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
2855
2856 if (exec_ms < target_ms) break;
2857 }
2858
2859 // now the same for kernel-accel but with the new kernel-loops from previous loop set
2860
2861 if (kernel_accel_min < kernel_accel_max)
2862 {
2863 for (int i = 0; i < STEPS_CNT; i++)
2864 {
2865 const u32 kernel_accel_try = 1 << i;
2866
2867 if (kernel_accel_try < kernel_accel_min) continue;
2868 if (kernel_accel_try > kernel_accel_max) break;
2869
2870 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
2871
2872 if (exec_ms > target_ms) break;
2873
2874 exec_ms_final = exec_ms;
2875
2876 kernel_accel = kernel_accel_try;
2877 }
2878 }
2879
2880 // there's a chance that we have a fixed kernel_loops but not a fixed kernel_accel
2881 // in such a case the above function would not create any change
2882 // we'll use the runtime to find out if we're allow to do last improvement
2883
2884 if (exec_ms_final > 0)
2885 {
2886 if ((exec_ms_final * 2) <= target_ms)
2887 {
2888 const double exec_left = target_ms / exec_ms_final;
2889
2890 const double accel_left = kernel_accel_max / kernel_accel;
2891
2892 const int exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
2893
2894 if (exec_accel_min >= 2)
2895 {
2896 kernel_accel *= exec_accel_min;
2897 }
2898 }
2899 }
2900
2901 // balancing the workload turns out to be very efficient
2902
2903 if (kernel_loops_min != kernel_loops_max)
2904 {
2905 const u32 kernel_power_balance = kernel_accel * kernel_loops;
2906
2907 u32 sqrtv;
2908
2909 for (sqrtv = 1; sqrtv < 0x100000; sqrtv++)
2910 {
2911 if ((sqrtv * sqrtv) >= kernel_power_balance) break;
2912 }
2913
2914 const u32 kernel_accel_try = sqrtv;
2915 const u32 kernel_loops_try = sqrtv;
2916
2917 if ((kernel_accel_try <= kernel_accel_max) && (kernel_loops_try >= kernel_loops_min))
2918 {
2919 kernel_accel = kernel_accel_try;
2920 kernel_loops = kernel_loops_try;
2921 }
2922 }
2923
2924 // reset fake words
2925
2926 memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
2927
2928 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, kernel_power_max * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2929 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_amp_buf, CL_TRUE, 0, kernel_power_max * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2930
2931 // reset timer
2932
2933 device_param->exec_pos = 0;
2934
2935 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
2936
2937 // store
2938
2939 device_param->kernel_accel = kernel_accel;
2940 device_param->kernel_loops = kernel_loops;
2941
2942 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
2943
2944 device_param->kernel_power = kernel_power;
2945
2946 #ifdef DEBUG
2947
2948 if (data.quiet == 0)
2949 {
2950 clear_prompt ();
2951
2952 log_info ("Device #%u: autotuned kernel-accel to %u\n"
2953 "Device #%u: autotuned kernel-loops to %u\n",
2954 device_param->device_id + 1, kernel_accel,
2955 device_param->device_id + 1, kernel_loops);
2956
2957 fprintf (stdout, "%s", PROMPT);
2958
2959 fflush (stdout);
2960 }
2961
2962 #endif
2963 }
2964
2965 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
2966 {
2967 char *line_buf = (char *) mymalloc (HCBUFSIZ);
2968
2969 // init speed timer
2970
2971 uint speed_pos = device_param->speed_pos;
2972
2973 #ifdef _POSIX
2974 if (device_param->timer_speed.tv_sec == 0)
2975 {
2976 hc_timer_set (&device_param->timer_speed);
2977 }
2978 #endif
2979
2980 #ifdef _WIN
2981 if (device_param->timer_speed.QuadPart == 0)
2982 {
2983 hc_timer_set (&device_param->timer_speed);
2984 }
2985 #endif
2986
2987 // find higest password length, this is for optimization stuff
2988
2989 uint highest_pw_len = 0;
2990
2991 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2992 {
2993 }
2994 else if (data.attack_kern == ATTACK_KERN_COMBI)
2995 {
2996 }
2997 else if (data.attack_kern == ATTACK_KERN_BF)
2998 {
2999 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3000 + device_param->kernel_params_mp_l_buf32[5];
3001 }
3002
3003 // iteration type
3004
3005 uint innerloop_step = 0;
3006 uint innerloop_cnt = 0;
3007
3008 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3009 else innerloop_step = 1;
3010
3011 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3012 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3013 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3014
3015 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3016
3017 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3018 {
3019 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3020
3021 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3022
3023 if (data.devices_status == STATUS_CRACKED) break;
3024 if (data.devices_status == STATUS_ABORTED) break;
3025 if (data.devices_status == STATUS_QUIT) break;
3026 if (data.devices_status == STATUS_BYPASS) break;
3027
3028 salt_t *salt_buf = &data.salts_buf[salt_pos];
3029
3030 device_param->kernel_params_buf32[24] = salt_pos;
3031 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3032 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3033
3034 FILE *combs_fp = device_param->combs_fp;
3035
3036 if (data.attack_mode == ATTACK_MODE_COMBI)
3037 {
3038 rewind (combs_fp);
3039 }
3040
3041 // innerloops
3042
3043 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3044 {
3045 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3046
3047 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3048
3049 if (data.devices_status == STATUS_CRACKED) break;
3050 if (data.devices_status == STATUS_ABORTED) break;
3051 if (data.devices_status == STATUS_QUIT) break;
3052 if (data.devices_status == STATUS_BYPASS) break;
3053
3054 uint innerloop_left = innerloop_cnt - innerloop_pos;
3055
3056 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3057
3058 device_param->innerloop_pos = innerloop_pos;
3059 device_param->innerloop_left = innerloop_left;
3060
3061 device_param->kernel_params_buf32[27] = innerloop_left;
3062
3063 // i think we can get rid of this
3064 if (innerloop_left == 0)
3065 {
3066 puts ("bug, how should this happen????\n");
3067
3068 continue;
3069 }
3070
3071 if (data.salts_shown[salt_pos] == 1)
3072 {
3073 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3074
3075 continue;
3076 }
3077
3078 // initialize amplifiers
3079
3080 if (data.attack_mode == ATTACK_MODE_COMBI)
3081 {
3082 uint i = 0;
3083
3084 while (i < innerloop_left)
3085 {
3086 if (feof (combs_fp)) break;
3087
3088 int line_len = fgetl (combs_fp, line_buf);
3089
3090 if (line_len >= PW_MAX1) continue;
3091
3092 line_len = convert_from_hex (line_buf, line_len);
3093
3094 char *line_buf_new = line_buf;
3095
3096 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3097 {
3098 char rule_buf_out[BLOCK_SIZE] = { 0 };
3099
3100 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3101
3102 if (rule_len_out < 0)
3103 {
3104 data.words_progress_rejected[salt_pos] += pws_cnt;
3105
3106 continue;
3107 }
3108
3109 line_len = rule_len_out;
3110
3111 line_buf_new = rule_buf_out;
3112 }
3113
3114 line_len = MIN (line_len, PW_DICTMAX);
3115
3116 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3117
3118 memcpy (ptr, line_buf_new, line_len);
3119
3120 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3121
3122 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3123 {
3124 uppercase (ptr, line_len);
3125 }
3126
3127 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3128 {
3129 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3130 {
3131 ptr[line_len] = 0x80;
3132 }
3133
3134 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3135 {
3136 ptr[line_len] = 0x01;
3137 }
3138 }
3139
3140 device_param->combs_buf[i].pw_len = line_len;
3141
3142 i++;
3143 }
3144
3145 for (uint j = i; j < innerloop_left; j++)
3146 {
3147 device_param->combs_buf[j].i[0] = 0;
3148 device_param->combs_buf[j].i[1] = 0;
3149 device_param->combs_buf[j].i[2] = 0;
3150 device_param->combs_buf[j].i[3] = 0;
3151 device_param->combs_buf[j].i[4] = 0;
3152 device_param->combs_buf[j].i[5] = 0;
3153 device_param->combs_buf[j].i[6] = 0;
3154 device_param->combs_buf[j].i[7] = 0;
3155
3156 device_param->combs_buf[j].pw_len = 0;
3157 }
3158
3159 innerloop_left = i;
3160 }
3161 else if (data.attack_mode == ATTACK_MODE_BF)
3162 {
3163 u64 off = innerloop_pos;
3164
3165 device_param->kernel_params_mp_r_buf64[3] = off;
3166
3167 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3168 }
3169 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3170 {
3171 u64 off = innerloop_pos;
3172
3173 device_param->kernel_params_mp_buf64[3] = off;
3174
3175 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3176 }
3177 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3178 {
3179 u64 off = innerloop_pos;
3180
3181 device_param->kernel_params_mp_buf64[3] = off;
3182
3183 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3184 }
3185
3186 // copy amplifiers
3187
3188 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3189 {
3190 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);
3191 }
3192 else if (data.attack_mode == ATTACK_MODE_COMBI)
3193 {
3194 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);
3195 }
3196 else if (data.attack_mode == ATTACK_MODE_BF)
3197 {
3198 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);
3199 }
3200 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3201 {
3202 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);
3203 }
3204 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3205 {
3206 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);
3207 }
3208
3209 if (data.benchmark == 1)
3210 {
3211 hc_timer_set (&device_param->timer_speed);
3212 }
3213
3214 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3215
3216 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3217
3218 if (data.devices_status == STATUS_CRACKED) break;
3219 if (data.devices_status == STATUS_ABORTED) break;
3220 if (data.devices_status == STATUS_QUIT) break;
3221
3222 /**
3223 * result
3224 */
3225
3226 hc_thread_mutex_lock (mux_display);
3227
3228 check_cracked (device_param, salt_pos);
3229
3230 hc_thread_mutex_unlock (mux_display);
3231
3232 /**
3233 * progress
3234 */
3235
3236 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3237
3238 hc_thread_mutex_lock (mux_counter);
3239
3240 data.words_progress_done[salt_pos] += perf_sum_all;
3241
3242 hc_thread_mutex_unlock (mux_counter);
3243
3244 /**
3245 * speed
3246 */
3247
3248 double speed_ms;
3249
3250 hc_timer_get (device_param->timer_speed, speed_ms);
3251
3252 hc_timer_set (&device_param->timer_speed);
3253
3254 hc_thread_mutex_lock (mux_display);
3255
3256 // current speed
3257
3258 device_param->speed_cnt[speed_pos] = perf_sum_all;
3259
3260 device_param->speed_ms[speed_pos] = speed_ms;
3261
3262 hc_thread_mutex_unlock (mux_display);
3263
3264 speed_pos++;
3265
3266 if (speed_pos == SPEED_CACHE)
3267 {
3268 speed_pos = 0;
3269 }
3270
3271 /**
3272 * benchmark
3273 */
3274
3275 if (data.benchmark == 1) break;
3276 }
3277 }
3278
3279 device_param->speed_pos = speed_pos;
3280
3281 myfree (line_buf);
3282 }
3283
3284 static void load_segment (wl_data_t *wl_data, FILE *fd)
3285 {
3286 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3287
3288 wl_data->pos = 0;
3289
3290 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3291
3292 wl_data->buf[wl_data->cnt] = 0;
3293
3294 if (wl_data->cnt == 0) return;
3295
3296 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3297
3298 while (!feof (fd))
3299 {
3300 if (wl_data->cnt == wl_data->avail)
3301 {
3302 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3303
3304 wl_data->avail += wl_data->incr;
3305 }
3306
3307 const int c = fgetc (fd);
3308
3309 if (c == EOF) break;
3310
3311 wl_data->buf[wl_data->cnt] = (char) c;
3312
3313 wl_data->cnt++;
3314
3315 if (c == '\n') break;
3316 }
3317
3318 // ensure stream ends with a newline
3319
3320 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3321 {
3322 wl_data->cnt++;
3323
3324 wl_data->buf[wl_data->cnt - 1] = '\n';
3325 }
3326
3327 return;
3328 }
3329
3330 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3331 {
3332 char *ptr = buf;
3333
3334 for (u32 i = 0; i < sz; i++, ptr++)
3335 {
3336 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3337
3338 if (i == 7)
3339 {
3340 *off = i;
3341 *len = i;
3342
3343 return;
3344 }
3345
3346 if (*ptr != '\n') continue;
3347
3348 *off = i + 1;
3349
3350 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3351
3352 *len = i;
3353
3354 return;
3355 }
3356
3357 *off = sz;
3358 *len = sz;
3359 }
3360
3361 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3362 {
3363 char *ptr = buf;
3364
3365 for (u32 i = 0; i < sz; i++, ptr++)
3366 {
3367 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3368
3369 if (*ptr != '\n') continue;
3370
3371 *off = i + 1;
3372
3373 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3374
3375 *len = i;
3376
3377 return;
3378 }
3379
3380 *off = sz;
3381 *len = sz;
3382 }
3383
3384 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3385 {
3386 char *ptr = buf;
3387
3388 for (u32 i = 0; i < sz; i++, ptr++)
3389 {
3390 if (*ptr != '\n') continue;
3391
3392 *off = i + 1;
3393
3394 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3395
3396 *len = i;
3397
3398 return;
3399 }
3400
3401 *off = sz;
3402 *len = sz;
3403 }
3404
3405 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3406 {
3407 while (wl_data->pos < wl_data->cnt)
3408 {
3409 uint off;
3410 uint len;
3411
3412 char *ptr = wl_data->buf + wl_data->pos;
3413
3414 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3415
3416 wl_data->pos += off;
3417
3418 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3419 {
3420 char rule_buf_out[BLOCK_SIZE] = { 0 };
3421
3422 int rule_len_out = -1;
3423
3424 if (len < BLOCK_SIZE)
3425 {
3426 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3427 }
3428
3429 if (rule_len_out < 0)
3430 {
3431 continue;
3432 }
3433
3434 if (rule_len_out > PW_MAX)
3435 {
3436 continue;
3437 }
3438 }
3439 else
3440 {
3441 if (len > PW_MAX)
3442 {
3443 continue;
3444 }
3445 }
3446
3447 *out_buf = ptr;
3448 *out_len = len;
3449
3450 return;
3451 }
3452
3453 if (feof (fd))
3454 {
3455 fprintf (stderr, "BUG feof()!!\n");
3456
3457 return;
3458 }
3459
3460 load_segment (wl_data, fd);
3461
3462 get_next_word (wl_data, fd, out_buf, out_len);
3463 }
3464
3465 #ifdef _POSIX
3466 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3467 #endif
3468
3469 #ifdef _WIN
3470 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3471 #endif
3472 {
3473 hc_signal (NULL);
3474
3475 dictstat_t d;
3476
3477 d.cnt = 0;
3478
3479 #ifdef _POSIX
3480 fstat (fileno (fd), &d.stat);
3481 #endif
3482
3483 #ifdef _WIN
3484 _fstat64 (fileno (fd), &d.stat);
3485 #endif
3486
3487 d.stat.st_mode = 0;
3488 d.stat.st_nlink = 0;
3489 d.stat.st_uid = 0;
3490 d.stat.st_gid = 0;
3491 d.stat.st_rdev = 0;
3492 d.stat.st_atime = 0;
3493
3494 #ifdef _POSIX
3495 d.stat.st_blksize = 0;
3496 d.stat.st_blocks = 0;
3497 #endif
3498
3499 if (d.stat.st_size == 0) return 0;
3500
3501 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3502
3503 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3504 {
3505 if (d_cache)
3506 {
3507 u64 cnt = d_cache->cnt;
3508
3509 u64 keyspace = cnt;
3510
3511 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3512 {
3513 keyspace *= data.kernel_rules_cnt;
3514 }
3515 else if (data.attack_kern == ATTACK_KERN_COMBI)
3516 {
3517 keyspace *= data.combs_cnt;
3518 }
3519
3520 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);
3521 if (data.quiet == 0) log_info ("");
3522
3523 hc_signal (sigHandler_default);
3524
3525 return (keyspace);
3526 }
3527 }
3528
3529 time_t now = 0;
3530 time_t prev = 0;
3531
3532 u64 comp = 0;
3533 u64 cnt = 0;
3534 u64 cnt2 = 0;
3535
3536 while (!feof (fd))
3537 {
3538 load_segment (wl_data, fd);
3539
3540 comp += wl_data->cnt;
3541
3542 u32 i = 0;
3543
3544 while (i < wl_data->cnt)
3545 {
3546 u32 len;
3547 u32 off;
3548
3549 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3550
3551 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3552 {
3553 char rule_buf_out[BLOCK_SIZE] = { 0 };
3554
3555 int rule_len_out = -1;
3556
3557 if (len < BLOCK_SIZE)
3558 {
3559 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3560 }
3561
3562 if (rule_len_out < 0)
3563 {
3564 len = PW_MAX1;
3565 }
3566 else
3567 {
3568 len = rule_len_out;
3569 }
3570 }
3571
3572 if (len < PW_MAX1)
3573 {
3574 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3575 {
3576 cnt += data.kernel_rules_cnt;
3577 }
3578 else if (data.attack_kern == ATTACK_KERN_COMBI)
3579 {
3580 cnt += data.combs_cnt;
3581 }
3582
3583 d.cnt++;
3584 }
3585
3586 i += off;
3587
3588 cnt2++;
3589 }
3590
3591 time (&now);
3592
3593 if ((now - prev) == 0) continue;
3594
3595 float percent = (float) comp / (float) d.stat.st_size;
3596
3597 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);
3598
3599 time (&prev);
3600 }
3601
3602 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);
3603 if (data.quiet == 0) log_info ("");
3604
3605 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3606
3607 hc_signal (sigHandler_default);
3608
3609 return (cnt);
3610 }
3611
3612 static void *thread_monitor (void *p)
3613 {
3614 uint runtime_check = 0;
3615 uint remove_check = 0;
3616 uint status_check = 0;
3617 uint restore_check = 0;
3618
3619 uint restore_left = data.restore_timer;
3620 uint remove_left = data.remove_timer;
3621 uint status_left = data.status_timer;
3622
3623 #ifdef HAVE_HWMON
3624 uint hwmon_check = 0;
3625
3626 // these variables are mainly used for fan control (AMD only)
3627
3628 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3629
3630 // temperature controller "loopback" values
3631
3632 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3633 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3634
3635 #ifdef HAVE_ADL
3636 int temp_threshold = 1; // degrees celcius
3637
3638 int fan_speed_min = 15; // in percentage
3639 int fan_speed_max = 100;
3640 #endif // HAVE_ADL
3641
3642 time_t last_temp_check_time;
3643 #endif // HAVE_HWMON
3644
3645 uint sleep_time = 1;
3646
3647 if (data.runtime)
3648 {
3649 runtime_check = 1;
3650 }
3651
3652 if (data.restore_timer)
3653 {
3654 restore_check = 1;
3655 }
3656
3657 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3658 {
3659 remove_check = 1;
3660 }
3661
3662 if (data.status == 1)
3663 {
3664 status_check = 1;
3665 }
3666
3667 #ifdef HAVE_HWMON
3668 if (data.gpu_temp_disable == 0)
3669 {
3670 time (&last_temp_check_time);
3671
3672 hwmon_check = 1;
3673 }
3674 #endif
3675
3676 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3677 {
3678 #ifdef HAVE_HWMON
3679 if (hwmon_check == 0)
3680 #endif
3681 return (p);
3682 }
3683
3684 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3685 {
3686 hc_sleep (sleep_time);
3687
3688 if (data.devices_status != STATUS_RUNNING) continue;
3689
3690 #ifdef HAVE_HWMON
3691 if (hwmon_check == 1)
3692 {
3693 hc_thread_mutex_lock (mux_adl);
3694
3695 time_t temp_check_time;
3696
3697 time (&temp_check_time);
3698
3699 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3700
3701 if (Ta == 0) Ta = 1;
3702
3703 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3704 {
3705 hc_device_param_t *device_param = &data.devices_param[device_id];
3706
3707 if (device_param->skipped) continue;
3708
3709 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3710
3711 const int temperature = hm_get_temperature_with_device_id (device_id);
3712
3713 if (temperature > (int) data.gpu_temp_abort)
3714 {
3715 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3716
3717 if (data.devices_status != STATUS_QUIT) myabort ();
3718
3719 break;
3720 }
3721
3722 #ifdef HAVE_ADL
3723 const int gpu_temp_retain = data.gpu_temp_retain;
3724
3725 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3726 {
3727 if (data.hm_device[device_id].fan_supported == 1)
3728 {
3729 int temp_cur = temperature;
3730
3731 int temp_diff_new = gpu_temp_retain - temp_cur;
3732
3733 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3734
3735 // calculate Ta value (time difference in seconds between the last check and this check)
3736
3737 last_temp_check_time = temp_check_time;
3738
3739 float Kp = 1.8;
3740 float Ki = 0.005;
3741 float Kd = 6;
3742
3743 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3744
3745 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);
3746
3747 if (abs (fan_diff_required) >= temp_threshold)
3748 {
3749 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3750
3751 int fan_speed_level = fan_speed_cur;
3752
3753 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3754
3755 int fan_speed_new = fan_speed_level - fan_diff_required;
3756
3757 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3758 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3759
3760 if (fan_speed_new != fan_speed_cur)
3761 {
3762 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3763 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3764
3765 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3766 {
3767 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3768
3769 fan_speed_chgd[device_id] = 1;
3770 }
3771
3772 temp_diff_old[device_id] = temp_diff_new;
3773 }
3774 }
3775 }
3776 }
3777 #endif // HAVE_ADL
3778 }
3779
3780 hc_thread_mutex_unlock (mux_adl);
3781 }
3782 #endif // HAVE_HWMON
3783
3784 if (restore_check == 1)
3785 {
3786 restore_left--;
3787
3788 if (restore_left == 0)
3789 {
3790 if (data.restore_disable == 0) cycle_restore ();
3791
3792 restore_left = data.restore_timer;
3793 }
3794 }
3795
3796 if ((runtime_check == 1) && (data.runtime_start > 0))
3797 {
3798 time_t runtime_cur;
3799
3800 time (&runtime_cur);
3801
3802 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3803
3804 if (runtime_left <= 0)
3805 {
3806 if (data.benchmark == 0)
3807 {
3808 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3809 }
3810
3811 if (data.devices_status != STATUS_QUIT) myabort ();
3812 }
3813 }
3814
3815 if (remove_check == 1)
3816 {
3817 remove_left--;
3818
3819 if (remove_left == 0)
3820 {
3821 if (data.digests_saved != data.digests_done)
3822 {
3823 data.digests_saved = data.digests_done;
3824
3825 save_hash ();
3826 }
3827
3828 remove_left = data.remove_timer;
3829 }
3830 }
3831
3832 if (status_check == 1)
3833 {
3834 status_left--;
3835
3836 if (status_left == 0)
3837 {
3838 hc_thread_mutex_lock (mux_display);
3839
3840 if (data.quiet == 0) clear_prompt ();
3841
3842 if (data.quiet == 0) log_info ("");
3843
3844 status_display ();
3845
3846 if (data.quiet == 0) log_info ("");
3847
3848 hc_thread_mutex_unlock (mux_display);
3849
3850 status_left = data.status_timer;
3851 }
3852 }
3853 }
3854
3855 #ifdef HAVE_HWMON
3856 myfree (fan_speed_chgd);
3857
3858 myfree (temp_diff_old);
3859 myfree (temp_diff_sum);
3860 #endif
3861
3862 p = NULL;
3863
3864 return (p);
3865 }
3866
3867 static void *thread_outfile_remove (void *p)
3868 {
3869 // some hash-dependent constants
3870 char *outfile_dir = data.outfile_check_directory;
3871 uint dgst_size = data.dgst_size;
3872 uint isSalted = data.isSalted;
3873 uint esalt_size = data.esalt_size;
3874 uint hash_mode = data.hash_mode;
3875
3876 uint outfile_check_timer = data.outfile_check_timer;
3877
3878 char separator = data.separator;
3879
3880 // some hash-dependent functions
3881 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3882 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3883
3884 // buffers
3885 hash_t hash_buf = { 0, 0, 0, 0, 0 };
3886
3887 hash_buf.digest = mymalloc (dgst_size);
3888
3889 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3890
3891 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3892
3893 uint digest_buf[64] = { 0 };
3894
3895 outfile_data_t *out_info = NULL;
3896
3897 char **out_files = NULL;
3898
3899 time_t folder_mtime = 0;
3900
3901 int out_cnt = 0;
3902
3903 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
3904
3905 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3906 {
3907 hc_sleep (1);
3908
3909 if (data.devices_status != STATUS_RUNNING) continue;
3910
3911 check_left--;
3912
3913 if (check_left == 0)
3914 {
3915 struct stat outfile_check_stat;
3916
3917 if (stat (outfile_dir, &outfile_check_stat) == 0)
3918 {
3919 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
3920
3921 if (is_dir == 1)
3922 {
3923 if (outfile_check_stat.st_mtime > folder_mtime)
3924 {
3925 char **out_files_new = scan_directory (outfile_dir);
3926
3927 int out_cnt_new = count_dictionaries (out_files_new);
3928
3929 outfile_data_t *out_info_new = NULL;
3930
3931 if (out_cnt_new > 0)
3932 {
3933 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
3934
3935 for (int i = 0; i < out_cnt_new; i++)
3936 {
3937 out_info_new[i].file_name = out_files_new[i];
3938
3939 // check if there are files that we have seen/checked before (and not changed)
3940
3941 for (int j = 0; j < out_cnt; j++)
3942 {
3943 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
3944 {
3945 struct stat outfile_stat;
3946
3947 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
3948 {
3949 if (outfile_stat.st_ctime == out_info[j].ctime)
3950 {
3951 out_info_new[i].ctime = out_info[j].ctime;
3952 out_info_new[i].seek = out_info[j].seek;
3953 }
3954 }
3955 }
3956 }
3957 }
3958 }
3959
3960 local_free (out_info);
3961 local_free (out_files);
3962
3963 out_files = out_files_new;
3964 out_cnt = out_cnt_new;
3965 out_info = out_info_new;
3966
3967 folder_mtime = outfile_check_stat.st_mtime;
3968 }
3969
3970 for (int j = 0; j < out_cnt; j++)
3971 {
3972 FILE *fp = fopen (out_info[j].file_name, "rb");
3973
3974 if (fp != NULL)
3975 {
3976 //hc_thread_mutex_lock (mux_display);
3977
3978 #ifdef _POSIX
3979 struct stat outfile_stat;
3980
3981 fstat (fileno (fp), &outfile_stat);
3982 #endif
3983
3984 #ifdef _WIN
3985 struct stat64 outfile_stat;
3986
3987 _fstat64 (fileno (fp), &outfile_stat);
3988 #endif
3989
3990 if (outfile_stat.st_ctime > out_info[j].ctime)
3991 {
3992 out_info[j].ctime = outfile_stat.st_ctime;
3993 out_info[j].seek = 0;
3994 }
3995
3996 fseek (fp, out_info[j].seek, SEEK_SET);
3997
3998 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3999
4000 while (!feof (fp))
4001 {
4002 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4003
4004 if (ptr == NULL) break;
4005
4006 int line_len = strlen (line_buf);
4007
4008 if (line_len <= 0) continue;
4009
4010 int iter = MAX_CUT_TRIES;
4011
4012 for (uint i = line_len - 1; i && iter; i--, line_len--)
4013 {
4014 if (line_buf[i] != separator) continue;
4015
4016 int parser_status = PARSER_OK;
4017
4018 if ((hash_mode != 2500) && (hash_mode != 6800))
4019 {
4020 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4021 }
4022
4023 uint found = 0;
4024
4025 if (parser_status == PARSER_OK)
4026 {
4027 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4028 {
4029 if (data.salts_shown[salt_pos] == 1) continue;
4030
4031 salt_t *salt_buf = &data.salts_buf[salt_pos];
4032
4033 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4034 {
4035 uint idx = salt_buf->digests_offset + digest_pos;
4036
4037 if (data.digests_shown[idx] == 1) continue;
4038
4039 uint cracked = 0;
4040
4041 if (hash_mode == 6800)
4042 {
4043 if (i == salt_buf->salt_len)
4044 {
4045 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4046 }
4047 }
4048 else if (hash_mode == 2500)
4049 {
4050 // BSSID : MAC1 : MAC2 (:plain)
4051 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4052 {
4053 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4054
4055 if (!cracked) continue;
4056
4057 // now compare MAC1 and MAC2 too, since we have this additional info
4058 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4059 char *mac2_pos = mac1_pos + 12 + 1;
4060
4061 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4062 wpa_t *wpa = &wpas[salt_pos];
4063
4064 // compare hex string(s) vs binary MAC address(es)
4065
4066 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4067 {
4068 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4069 {
4070 cracked = 0;
4071
4072 break;
4073 }
4074 }
4075
4076 // early skip ;)
4077 if (!cracked) continue;
4078
4079 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4080 {
4081 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4082 {
4083 cracked = 0;
4084
4085 break;
4086 }
4087 }
4088 }
4089 }
4090 else
4091 {
4092 char *digests_buf_ptr = (char *) data.digests_buf;
4093
4094 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4095
4096 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4097 }
4098
4099 if (cracked == 1)
4100 {
4101 found = 1;
4102
4103 data.digests_shown[idx] = 1;
4104
4105 data.digests_done++;
4106
4107 salt_buf->digests_done++;
4108
4109 if (salt_buf->digests_done == salt_buf->digests_cnt)
4110 {
4111 data.salts_shown[salt_pos] = 1;
4112
4113 data.salts_done++;
4114
4115 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4116 }
4117 }
4118 }
4119
4120 if (data.devices_status == STATUS_CRACKED) break;
4121 }
4122 }
4123
4124 if (found) break;
4125
4126 if (data.devices_status == STATUS_CRACKED) break;
4127
4128 iter--;
4129 }
4130
4131 if (data.devices_status == STATUS_CRACKED) break;
4132 }
4133
4134 myfree (line_buf);
4135
4136 out_info[j].seek = ftell (fp);
4137
4138 //hc_thread_mutex_unlock (mux_display);
4139
4140 fclose (fp);
4141 }
4142 }
4143 }
4144 }
4145
4146 check_left = outfile_check_timer;
4147 }
4148 }
4149
4150 if (esalt_size) local_free (hash_buf.esalt);
4151
4152 if (isSalted) local_free (hash_buf.salt);
4153
4154 local_free (hash_buf.digest);
4155
4156 local_free (out_info);
4157
4158 local_free (out_files);
4159
4160 p = NULL;
4161
4162 return (p);
4163 }
4164
4165 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4166 {
4167 if (device_param->pws_cnt < device_param->kernel_power)
4168 {
4169 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4170
4171 u8 *ptr = (u8 *) pw->i;
4172
4173 memcpy (ptr, pw_buf, pw_len);
4174
4175 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4176
4177 pw->pw_len = pw_len;
4178
4179 device_param->pws_cnt++;
4180 }
4181 else
4182 {
4183 fprintf (stderr, "BUG pw_add()!!\n");
4184
4185 return;
4186 }
4187 }
4188
4189 static uint get_work (hc_device_param_t *device_param, const u64 max, const bool allow_div)
4190 {
4191 hc_thread_mutex_lock (mux_dispatcher);
4192
4193 const u64 words_cur = data.words_cur;
4194 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4195
4196 device_param->words_off = words_cur;
4197
4198 const u64 words_left = words_base - words_cur;
4199
4200 if (allow_div)
4201 {
4202 if (data.kernel_power_all > words_left)
4203 {
4204 if (data.kernel_power_div == 0)
4205 {
4206 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4207 }
4208 }
4209
4210 if (data.kernel_power_div)
4211 {
4212 if (device_param->kernel_power == device_param->kernel_power_user)
4213 {
4214 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4215
4216 if (kernel_power_new < device_param->kernel_power)
4217 {
4218 device_param->kernel_power = kernel_power_new;
4219 }
4220 }
4221 }
4222 }
4223
4224 const uint kernel_power = device_param->kernel_power;
4225
4226 uint work = MIN (words_left, kernel_power);
4227
4228 work = MIN (work, max);
4229
4230 data.words_cur += work;
4231
4232 hc_thread_mutex_unlock (mux_dispatcher);
4233
4234 return work;
4235 }
4236
4237 static void *thread_calc_stdin (void *p)
4238 {
4239 hc_device_param_t *device_param = (hc_device_param_t *) p;
4240
4241 if (device_param->skipped) return NULL;
4242
4243 autotune (device_param);
4244
4245 char *buf = (char *) mymalloc (HCBUFSIZ);
4246
4247 const uint attack_kern = data.attack_kern;
4248
4249 const uint kernel_power = device_param->kernel_power;
4250
4251 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4252 {
4253 hc_thread_mutex_lock (mux_dispatcher);
4254
4255 if (feof (stdin) != 0)
4256 {
4257 hc_thread_mutex_unlock (mux_dispatcher);
4258
4259 break;
4260 }
4261
4262 uint words_cur = 0;
4263
4264 while (words_cur < kernel_power)
4265 {
4266 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4267
4268 if (line_buf == NULL) break;
4269
4270 uint line_len = in_superchop (line_buf);
4271
4272 line_len = convert_from_hex (line_buf, line_len);
4273
4274 // post-process rule engine
4275
4276 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4277 {
4278 char rule_buf_out[BLOCK_SIZE] = { 0 };
4279
4280 int rule_len_out = -1;
4281
4282 if (line_len < BLOCK_SIZE)
4283 {
4284 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4285 }
4286
4287 if (rule_len_out < 0) continue;
4288
4289 line_buf = rule_buf_out;
4290 line_len = rule_len_out;
4291 }
4292
4293 if (line_len > PW_MAX)
4294 {
4295 continue;
4296 }
4297
4298 if (attack_kern == ATTACK_KERN_STRAIGHT)
4299 {
4300 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4301 {
4302 hc_thread_mutex_lock (mux_counter);
4303
4304 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4305 {
4306 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4307 }
4308
4309 hc_thread_mutex_unlock (mux_counter);
4310
4311 continue;
4312 }
4313 }
4314 else if (attack_kern == ATTACK_KERN_COMBI)
4315 {
4316 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4317 // since we still need to combine the plains
4318
4319 if (line_len > data.pw_max)
4320 {
4321 hc_thread_mutex_lock (mux_counter);
4322
4323 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4324 {
4325 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4326 }
4327
4328 hc_thread_mutex_unlock (mux_counter);
4329
4330 continue;
4331 }
4332 }
4333
4334 pw_add (device_param, (u8 *) line_buf, line_len);
4335
4336 words_cur++;
4337
4338 if (data.devices_status == STATUS_CRACKED) break;
4339 if (data.devices_status == STATUS_ABORTED) break;
4340 if (data.devices_status == STATUS_QUIT) break;
4341 if (data.devices_status == STATUS_BYPASS) break;
4342 }
4343
4344 hc_thread_mutex_unlock (mux_dispatcher);
4345
4346 if (data.devices_status == STATUS_CRACKED) break;
4347 if (data.devices_status == STATUS_ABORTED) break;
4348 if (data.devices_status == STATUS_QUIT) break;
4349 if (data.devices_status == STATUS_BYPASS) break;
4350
4351 // flush
4352
4353 const uint pws_cnt = device_param->pws_cnt;
4354
4355 if (pws_cnt)
4356 {
4357 run_copy (device_param, pws_cnt);
4358
4359 run_cracker (device_param, pws_cnt);
4360
4361 device_param->pws_cnt = 0;
4362
4363 if (attack_kern == ATTACK_KERN_STRAIGHT)
4364 {
4365 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4366 }
4367 else if (attack_kern == ATTACK_KERN_COMBI)
4368 {
4369 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4370 }
4371 }
4372 }
4373
4374 device_param->kernel_accel = 0;
4375 device_param->kernel_loops = 0;
4376
4377 myfree (buf);
4378
4379 return NULL;
4380 }
4381
4382 static void *thread_calc (void *p)
4383 {
4384 hc_device_param_t *device_param = (hc_device_param_t *) p;
4385
4386 if (device_param->skipped) return NULL;
4387
4388 autotune (device_param);
4389
4390 const uint attack_mode = data.attack_mode;
4391 const uint attack_kern = data.attack_kern;
4392
4393 if (attack_mode == ATTACK_MODE_BF)
4394 {
4395 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4396 {
4397 const uint work = get_work (device_param, -1, true);
4398
4399 if (work == 0) break;
4400
4401 const u64 words_off = device_param->words_off;
4402 const u64 words_fin = words_off + work;
4403
4404 const uint pws_cnt = work;
4405
4406 device_param->pws_cnt = pws_cnt;
4407
4408 if (pws_cnt)
4409 {
4410 run_copy (device_param, pws_cnt);
4411
4412 run_cracker (device_param, pws_cnt);
4413
4414 device_param->pws_cnt = 0;
4415
4416 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4417 }
4418
4419 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4420
4421 if (data.devices_status == STATUS_CRACKED) break;
4422 if (data.devices_status == STATUS_ABORTED) break;
4423 if (data.devices_status == STATUS_QUIT) break;
4424 if (data.devices_status == STATUS_BYPASS) break;
4425
4426 if (data.benchmark == 1) break;
4427
4428 device_param->words_done = words_fin;
4429 }
4430 }
4431 else
4432 {
4433 const uint segment_size = data.segment_size;
4434
4435 char *dictfile = data.dictfile;
4436
4437 if (attack_mode == ATTACK_MODE_COMBI)
4438 {
4439 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4440 {
4441 dictfile = data.dictfile2;
4442 }
4443 }
4444
4445 FILE *fd = fopen (dictfile, "rb");
4446
4447 if (fd == NULL)
4448 {
4449 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4450
4451 return NULL;
4452 }
4453
4454 if (attack_mode == ATTACK_MODE_COMBI)
4455 {
4456 const uint combs_mode = data.combs_mode;
4457
4458 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4459 {
4460 const char *dictfilec = data.dictfile2;
4461
4462 FILE *combs_fp = fopen (dictfilec, "rb");
4463
4464 if (combs_fp == NULL)
4465 {
4466 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4467
4468 fclose (fd);
4469
4470 return NULL;
4471 }
4472
4473 device_param->combs_fp = combs_fp;
4474 }
4475 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4476 {
4477 const char *dictfilec = data.dictfile;
4478
4479 FILE *combs_fp = fopen (dictfilec, "rb");
4480
4481 if (combs_fp == NULL)
4482 {
4483 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4484
4485 fclose (fd);
4486
4487 return NULL;
4488 }
4489
4490 device_param->combs_fp = combs_fp;
4491 }
4492 }
4493
4494 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4495
4496 wl_data->buf = (char *) mymalloc (segment_size);
4497 wl_data->avail = segment_size;
4498 wl_data->incr = segment_size;
4499 wl_data->cnt = 0;
4500 wl_data->pos = 0;
4501
4502 u64 words_cur = 0;
4503
4504 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4505 {
4506 u64 words_off = 0;
4507 u64 words_fin = 0;
4508
4509 bool allow_div = true;
4510
4511 u64 max = -1;
4512
4513 while (max)
4514 {
4515 const uint work = get_work (device_param, max, allow_div);
4516
4517 allow_div = false;
4518
4519 if (work == 0) break;
4520
4521 words_off = device_param->words_off;
4522 words_fin = words_off + work;
4523
4524 char *line_buf;
4525 uint line_len;
4526
4527 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4528
4529 max = 0;
4530
4531 for ( ; words_cur < words_fin; words_cur++)
4532 {
4533 get_next_word (wl_data, fd, &line_buf, &line_len);
4534
4535 line_len = convert_from_hex (line_buf, line_len);
4536
4537 // post-process rule engine
4538
4539 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4540 {
4541 char rule_buf_out[BLOCK_SIZE] = { 0 };
4542
4543 int rule_len_out = -1;
4544
4545 if (line_len < BLOCK_SIZE)
4546 {
4547 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4548 }
4549
4550 if (rule_len_out < 0) continue;
4551
4552 line_buf = rule_buf_out;
4553 line_len = rule_len_out;
4554 }
4555
4556 if (attack_kern == ATTACK_KERN_STRAIGHT)
4557 {
4558 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4559 {
4560 max++;
4561
4562 hc_thread_mutex_lock (mux_counter);
4563
4564 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4565 {
4566 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4567 }
4568
4569 hc_thread_mutex_unlock (mux_counter);
4570
4571 continue;
4572 }
4573 }
4574 else if (attack_kern == ATTACK_KERN_COMBI)
4575 {
4576 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4577 // since we still need to combine the plains
4578
4579 if (line_len > data.pw_max)
4580 {
4581 max++;
4582
4583 hc_thread_mutex_lock (mux_counter);
4584
4585 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4586 {
4587 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4588 }
4589
4590 hc_thread_mutex_unlock (mux_counter);
4591
4592 continue;
4593 }
4594 }
4595
4596 pw_add (device_param, (u8 *) line_buf, line_len);
4597
4598 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4599
4600 if (data.devices_status == STATUS_CRACKED) break;
4601 if (data.devices_status == STATUS_ABORTED) break;
4602 if (data.devices_status == STATUS_QUIT) break;
4603 if (data.devices_status == STATUS_BYPASS) break;
4604 }
4605
4606 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4607
4608 if (data.devices_status == STATUS_CRACKED) break;
4609 if (data.devices_status == STATUS_ABORTED) break;
4610 if (data.devices_status == STATUS_QUIT) break;
4611 if (data.devices_status == STATUS_BYPASS) break;
4612 }
4613
4614 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4615
4616 if (data.devices_status == STATUS_CRACKED) break;
4617 if (data.devices_status == STATUS_ABORTED) break;
4618 if (data.devices_status == STATUS_QUIT) break;
4619 if (data.devices_status == STATUS_BYPASS) break;
4620
4621 //
4622 // flush
4623 //
4624
4625 const uint pws_cnt = device_param->pws_cnt;
4626
4627 if (pws_cnt)
4628 {
4629 run_copy (device_param, pws_cnt);
4630
4631 run_cracker (device_param, pws_cnt);
4632
4633 device_param->pws_cnt = 0;
4634
4635 if (attack_kern == ATTACK_KERN_STRAIGHT)
4636 {
4637 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4638 }
4639 else if (attack_kern == ATTACK_KERN_COMBI)
4640 {
4641 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4642 }
4643 }
4644
4645 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4646
4647 if (data.devices_status == STATUS_CRACKED) break;
4648 if (data.devices_status == STATUS_ABORTED) break;
4649 if (data.devices_status == STATUS_QUIT) break;
4650 if (data.devices_status == STATUS_BYPASS) break;
4651
4652 if (words_fin == 0) break;
4653
4654 device_param->words_done = words_fin;
4655 }
4656
4657 if (attack_mode == ATTACK_MODE_COMBI)
4658 {
4659 fclose (device_param->combs_fp);
4660 }
4661
4662 free (wl_data->buf);
4663 free (wl_data);
4664
4665 fclose (fd);
4666 }
4667
4668 device_param->kernel_accel = 0;
4669 device_param->kernel_loops = 0;
4670
4671 return NULL;
4672 }
4673
4674 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4675 {
4676 if (!device_param)
4677 {
4678 log_error ("ERROR: %s : Invalid argument", __func__);
4679
4680 exit (-1);
4681 }
4682
4683 salt_t *salt_buf = &data.salts_buf[salt_pos];
4684
4685 device_param->kernel_params_buf32[24] = salt_pos;
4686 device_param->kernel_params_buf32[27] = 1;
4687 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4688 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4689 device_param->kernel_params_buf32[30] = 0;
4690 device_param->kernel_params_buf32[31] = 1;
4691
4692 char *dictfile_old = data.dictfile;
4693
4694 const char *weak_hash_check = "weak-hash-check";
4695
4696 data.dictfile = (char *) weak_hash_check;
4697
4698 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4699
4700 data.kernel_rules_buf[0].cmds[0] = 0;
4701
4702 /**
4703 * run the kernel
4704 */
4705
4706 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4707 {
4708 run_kernel (KERN_RUN_1, device_param, 1, false);
4709 }
4710 else
4711 {
4712 run_kernel (KERN_RUN_1, device_param, 1, false);
4713
4714 uint loop_step = 16;
4715
4716 const uint iter = salt_buf->salt_iter;
4717
4718 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4719 {
4720 uint loop_left = iter - loop_pos;
4721
4722 loop_left = MIN (loop_left, loop_step);
4723
4724 device_param->kernel_params_buf32[25] = loop_pos;
4725 device_param->kernel_params_buf32[26] = loop_left;
4726
4727 run_kernel (KERN_RUN_2, device_param, 1, false);
4728 }
4729
4730 run_kernel (KERN_RUN_3, device_param, 1, false);
4731 }
4732
4733 /**
4734 * result
4735 */
4736
4737 check_cracked (device_param, salt_pos);
4738
4739 /**
4740 * cleanup
4741 */
4742
4743 device_param->kernel_params_buf32[24] = 0;
4744 device_param->kernel_params_buf32[25] = 0;
4745 device_param->kernel_params_buf32[26] = 0;
4746 device_param->kernel_params_buf32[27] = 0;
4747 device_param->kernel_params_buf32[28] = 0;
4748 device_param->kernel_params_buf32[29] = 0;
4749 device_param->kernel_params_buf32[30] = 0;
4750 device_param->kernel_params_buf32[31] = 0;
4751
4752 data.dictfile = dictfile_old;
4753
4754 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4755 }
4756
4757 // hlfmt hashcat
4758
4759 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4760 {
4761 if (data.username == 0)
4762 {
4763 *hashbuf_pos = line_buf;
4764 *hashbuf_len = line_len;
4765 }
4766 else
4767 {
4768 char *pos = line_buf;
4769 int len = line_len;
4770
4771 for (int i = 0; i < line_len; i++, pos++, len--)
4772 {
4773 if (line_buf[i] == data.separator)
4774 {
4775 pos++;
4776
4777 len--;
4778
4779 break;
4780 }
4781 }
4782
4783 *hashbuf_pos = pos;
4784 *hashbuf_len = len;
4785 }
4786 }
4787
4788 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4789 {
4790 char *pos = NULL;
4791 int len = 0;
4792
4793 int sep_cnt = 0;
4794
4795 for (int i = 0; i < line_len; i++)
4796 {
4797 if (line_buf[i] == data.separator)
4798 {
4799 sep_cnt++;
4800
4801 continue;
4802 }
4803
4804 if (sep_cnt == 0)
4805 {
4806 if (pos == NULL) pos = line_buf + i;
4807
4808 len++;
4809 }
4810 }
4811
4812 *userbuf_pos = pos;
4813 *userbuf_len = len;
4814 }
4815
4816 // hlfmt pwdump
4817
4818 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
4819 {
4820 int sep_cnt = 0;
4821
4822 int sep2_len = 0;
4823 int sep3_len = 0;
4824
4825 for (int i = 0; i < line_len; i++)
4826 {
4827 if (line_buf[i] == ':')
4828 {
4829 sep_cnt++;
4830
4831 continue;
4832 }
4833
4834 if (sep_cnt == 2) sep2_len++;
4835 if (sep_cnt == 3) sep3_len++;
4836 }
4837
4838 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4839
4840 return 0;
4841 }
4842
4843 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4844 {
4845 char *pos = NULL;
4846 int len = 0;
4847
4848 int sep_cnt = 0;
4849
4850 for (int i = 0; i < line_len; i++)
4851 {
4852 if (line_buf[i] == ':')
4853 {
4854 sep_cnt++;
4855
4856 continue;
4857 }
4858
4859 if (data.hash_mode == 1000)
4860 {
4861 if (sep_cnt == 3)
4862 {
4863 if (pos == NULL) pos = line_buf + i;
4864
4865 len++;
4866 }
4867 }
4868 else if (data.hash_mode == 3000)
4869 {
4870 if (sep_cnt == 2)
4871 {
4872 if (pos == NULL) pos = line_buf + i;
4873
4874 len++;
4875 }
4876 }
4877 }
4878
4879 *hashbuf_pos = pos;
4880 *hashbuf_len = len;
4881 }
4882
4883 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4884 {
4885 char *pos = NULL;
4886 int len = 0;
4887
4888 int sep_cnt = 0;
4889
4890 for (int i = 0; i < line_len; i++)
4891 {
4892 if (line_buf[i] == ':')
4893 {
4894 sep_cnt++;
4895
4896 continue;
4897 }
4898
4899 if (sep_cnt == 0)
4900 {
4901 if (pos == NULL) pos = line_buf + i;
4902
4903 len++;
4904 }
4905 }
4906
4907 *userbuf_pos = pos;
4908 *userbuf_len = len;
4909 }
4910
4911 // hlfmt passwd
4912
4913 static int hlfmt_detect_passwd (char *line_buf, int line_len)
4914 {
4915 int sep_cnt = 0;
4916
4917 char sep5_first = 0;
4918 char sep6_first = 0;
4919
4920 for (int i = 0; i < line_len; i++)
4921 {
4922 if (line_buf[i] == ':')
4923 {
4924 sep_cnt++;
4925
4926 continue;
4927 }
4928
4929 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
4930 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
4931 }
4932
4933 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
4934
4935 return 0;
4936 }
4937
4938 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4939 {
4940 char *pos = NULL;
4941 int len = 0;
4942
4943 int sep_cnt = 0;
4944
4945 for (int i = 0; i < line_len; i++)
4946 {
4947 if (line_buf[i] == ':')
4948 {
4949 sep_cnt++;
4950
4951 continue;
4952 }
4953
4954 if (sep_cnt == 1)
4955 {
4956 if (pos == NULL) pos = line_buf + i;
4957
4958 len++;
4959 }
4960 }
4961
4962 *hashbuf_pos = pos;
4963 *hashbuf_len = len;
4964 }
4965
4966 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4967 {
4968 char *pos = NULL;
4969 int len = 0;
4970
4971 int sep_cnt = 0;
4972
4973 for (int i = 0; i < line_len; i++)
4974 {
4975 if (line_buf[i] == ':')
4976 {
4977 sep_cnt++;
4978
4979 continue;
4980 }
4981
4982 if (sep_cnt == 0)
4983 {
4984 if (pos == NULL) pos = line_buf + i;
4985
4986 len++;
4987 }
4988 }
4989
4990 *userbuf_pos = pos;
4991 *userbuf_len = len;
4992 }
4993
4994 // hlfmt shadow
4995
4996 static int hlfmt_detect_shadow (char *line_buf, int line_len)
4997 {
4998 int sep_cnt = 0;
4999
5000 for (int i = 0; i < line_len; i++)
5001 {
5002 if (line_buf[i] == ':') sep_cnt++;
5003 }
5004
5005 if (sep_cnt == 8) return 1;
5006
5007 return 0;
5008 }
5009
5010 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5011 {
5012 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5013 }
5014
5015 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5016 {
5017 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5018 }
5019
5020 // hlfmt main
5021
5022 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5023 {
5024 switch (hashfile_format)
5025 {
5026 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5027 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5028 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5029 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5030 }
5031 }
5032
5033 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5034 {
5035 switch (hashfile_format)
5036 {
5037 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5038 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5039 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5040 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5041 }
5042 }
5043
5044 char *strhlfmt (const uint hashfile_format)
5045 {
5046 switch (hashfile_format)
5047 {
5048 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5049 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5050 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5051 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5052 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5053 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5054 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5055 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5056 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5057 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5058 }
5059
5060 return ((char *) "Unknown");
5061 }
5062
5063 static uint hlfmt_detect (FILE *fp, uint max_check)
5064 {
5065 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5066
5067 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5068 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5069
5070 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5071
5072 uint num_check = 0;
5073
5074 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5075
5076 while (!feof (fp))
5077 {
5078 int line_len = fgetl (fp, line_buf);
5079
5080 if (line_len == 0) continue;
5081
5082 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5083 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5084 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5085
5086 if (num_check == max_check) break;
5087
5088 num_check++;
5089 }
5090
5091 myfree (line_buf);
5092
5093 uint hashlist_format = HLFMT_HASHCAT;
5094
5095 for (int i = 1; i < HLFMTS_CNT; i++)
5096 {
5097 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5098
5099 hashlist_format = i;
5100 }
5101
5102 free (formats_cnt);
5103
5104 return hashlist_format;
5105 }
5106
5107 /**
5108 * some further helper function
5109 */
5110
5111 // wrapper around mymalloc for ADL
5112
5113 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5114 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5115 {
5116 return mymalloc (iSize);
5117 }
5118 #endif
5119
5120 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)
5121 {
5122 u64 collisions = 0;
5123
5124 const uint dgst_pos0 = data.dgst_pos0;
5125 const uint dgst_pos1 = data.dgst_pos1;
5126 const uint dgst_pos2 = data.dgst_pos2;
5127 const uint dgst_pos3 = data.dgst_pos3;
5128
5129 memset (bitmap_a, 0, bitmap_size);
5130 memset (bitmap_b, 0, bitmap_size);
5131 memset (bitmap_c, 0, bitmap_size);
5132 memset (bitmap_d, 0, bitmap_size);
5133
5134 for (uint i = 0; i < digests_cnt; i++)
5135 {
5136 uint *digest_ptr = (uint *) digests_buf_ptr;
5137
5138 digests_buf_ptr += dgst_size;
5139
5140 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5141 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5142 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5143 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5144
5145 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5146 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5147 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5148 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5149
5150 if (bitmap_a[idx0] & val0) collisions++;
5151 if (bitmap_b[idx1] & val1) collisions++;
5152 if (bitmap_c[idx2] & val2) collisions++;
5153 if (bitmap_d[idx3] & val3) collisions++;
5154
5155 bitmap_a[idx0] |= val0;
5156 bitmap_b[idx1] |= val1;
5157 bitmap_c[idx2] |= val2;
5158 bitmap_d[idx3] |= val3;
5159
5160 if (collisions >= collisions_max) return 0x7fffffff;
5161 }
5162
5163 return collisions;
5164 }
5165
5166 /**
5167 * main
5168 */
5169
5170 int main (int argc, char **argv)
5171 {
5172 /**
5173 * To help users a bit
5174 */
5175
5176 char *compute = getenv ("COMPUTE");
5177
5178 if (compute)
5179 {
5180 static char display[100];
5181
5182 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5183
5184 putenv (display);
5185 }
5186 else
5187 {
5188 if (getenv ("DISPLAY") == NULL)
5189 putenv ((char *) "DISPLAY=:0");
5190 }
5191
5192 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5193 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5194
5195 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5196 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5197
5198 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5199 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5200
5201 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5202 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5203
5204 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5205 putenv ((char *) "POCL_KERNEL_CACHE=0");
5206
5207 /**
5208 * Real init
5209 */
5210
5211 memset (&data, 0, sizeof (hc_global_data_t));
5212
5213 time_t proc_start;
5214
5215 time (&proc_start);
5216
5217 data.proc_start = proc_start;
5218
5219 int myargc = argc;
5220 char **myargv = argv;
5221
5222 hc_thread_mutex_init (mux_dispatcher);
5223 hc_thread_mutex_init (mux_counter);
5224 hc_thread_mutex_init (mux_display);
5225 hc_thread_mutex_init (mux_adl);
5226
5227 /**
5228 * commandline parameters
5229 */
5230
5231 uint usage = USAGE;
5232 uint version = VERSION;
5233 uint quiet = QUIET;
5234 uint benchmark = BENCHMARK;
5235 uint show = SHOW;
5236 uint left = LEFT;
5237 uint username = USERNAME;
5238 uint remove = REMOVE;
5239 uint remove_timer = REMOVE_TIMER;
5240 u64 skip = SKIP;
5241 u64 limit = LIMIT;
5242 uint keyspace = KEYSPACE;
5243 uint potfile_disable = POTFILE_DISABLE;
5244 char *potfile_path = NULL;
5245 uint debug_mode = DEBUG_MODE;
5246 char *debug_file = NULL;
5247 char *induction_dir = NULL;
5248 char *outfile_check_dir = NULL;
5249 uint force = FORCE;
5250 uint runtime = RUNTIME;
5251 uint hash_mode = HASH_MODE;
5252 uint attack_mode = ATTACK_MODE;
5253 uint markov_disable = MARKOV_DISABLE;
5254 uint markov_classic = MARKOV_CLASSIC;
5255 uint markov_threshold = MARKOV_THRESHOLD;
5256 char *markov_hcstat = NULL;
5257 char *outfile = NULL;
5258 uint outfile_format = OUTFILE_FORMAT;
5259 uint outfile_autohex = OUTFILE_AUTOHEX;
5260 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5261 uint restore = RESTORE;
5262 uint restore_timer = RESTORE_TIMER;
5263 uint restore_disable = RESTORE_DISABLE;
5264 uint status = STATUS;
5265 uint status_timer = STATUS_TIMER;
5266 uint status_automat = STATUS_AUTOMAT;
5267 uint loopback = LOOPBACK;
5268 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5269 char *session = NULL;
5270 uint hex_charset = HEX_CHARSET;
5271 uint hex_salt = HEX_SALT;
5272 uint hex_wordlist = HEX_WORDLIST;
5273 uint rp_gen = RP_GEN;
5274 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5275 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5276 uint rp_gen_seed = RP_GEN_SEED;
5277 char *rule_buf_l = (char *) RULE_BUF_L;
5278 char *rule_buf_r = (char *) RULE_BUF_R;
5279 uint increment = INCREMENT;
5280 uint increment_min = INCREMENT_MIN;
5281 uint increment_max = INCREMENT_MAX;
5282 char *cpu_affinity = NULL;
5283 OCL_PTR *ocl = NULL;
5284 char *opencl_devices = NULL;
5285 char *opencl_platforms = NULL;
5286 char *opencl_device_types = NULL;
5287 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5288 char *truecrypt_keyfiles = NULL;
5289 uint workload_profile = WORKLOAD_PROFILE;
5290 uint kernel_accel = KERNEL_ACCEL;
5291 uint kernel_loops = KERNEL_LOOPS;
5292 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5293 #ifdef HAVE_HWMON
5294 uint gpu_temp_abort = GPU_TEMP_ABORT;
5295 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5296 #ifdef HAVE_ADL
5297 uint powertune_enable = POWERTUNE_ENABLE;
5298 #endif
5299 #endif
5300 uint logfile_disable = LOGFILE_DISABLE;
5301 uint segment_size = SEGMENT_SIZE;
5302 uint scrypt_tmto = SCRYPT_TMTO;
5303 char separator = SEPARATOR;
5304 uint bitmap_min = BITMAP_MIN;
5305 uint bitmap_max = BITMAP_MAX;
5306 char *custom_charset_1 = NULL;
5307 char *custom_charset_2 = NULL;
5308 char *custom_charset_3 = NULL;
5309 char *custom_charset_4 = NULL;
5310
5311 #define IDX_HELP 'h'
5312 #define IDX_VERSION 'V'
5313 #define IDX_VERSION_LOWER 'v'
5314 #define IDX_QUIET 0xff02
5315 #define IDX_SHOW 0xff03
5316 #define IDX_LEFT 0xff04
5317 #define IDX_REMOVE 0xff05
5318 #define IDX_REMOVE_TIMER 0xff37
5319 #define IDX_SKIP 's'
5320 #define IDX_LIMIT 'l'
5321 #define IDX_KEYSPACE 0xff35
5322 #define IDX_POTFILE_DISABLE 0xff06
5323 #define IDX_POTFILE_PATH 0xffe0
5324 #define IDX_DEBUG_MODE 0xff43
5325 #define IDX_DEBUG_FILE 0xff44
5326 #define IDX_INDUCTION_DIR 0xff46
5327 #define IDX_OUTFILE_CHECK_DIR 0xff47
5328 #define IDX_USERNAME 0xff07
5329 #define IDX_FORCE 0xff08
5330 #define IDX_RUNTIME 0xff09
5331 #define IDX_BENCHMARK 'b'
5332 #define IDX_HASH_MODE 'm'
5333 #define IDX_ATTACK_MODE 'a'
5334 #define IDX_RP_FILE 'r'
5335 #define IDX_RP_GEN 'g'
5336 #define IDX_RP_GEN_FUNC_MIN 0xff10
5337 #define IDX_RP_GEN_FUNC_MAX 0xff11
5338 #define IDX_RP_GEN_SEED 0xff34
5339 #define IDX_RULE_BUF_L 'j'
5340 #define IDX_RULE_BUF_R 'k'
5341 #define IDX_INCREMENT 'i'
5342 #define IDX_INCREMENT_MIN 0xff12
5343 #define IDX_INCREMENT_MAX 0xff13
5344 #define IDX_OUTFILE 'o'
5345 #define IDX_OUTFILE_FORMAT 0xff14
5346 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5347 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5348 #define IDX_RESTORE 0xff15
5349 #define IDX_RESTORE_DISABLE 0xff27
5350 #define IDX_STATUS 0xff17
5351 #define IDX_STATUS_TIMER 0xff18
5352 #define IDX_STATUS_AUTOMAT 0xff50
5353 #define IDX_LOOPBACK 0xff38
5354 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5355 #define IDX_SESSION 0xff19
5356 #define IDX_HEX_CHARSET 0xff20
5357 #define IDX_HEX_SALT 0xff21
5358 #define IDX_HEX_WORDLIST 0xff40
5359 #define IDX_MARKOV_DISABLE 0xff22
5360 #define IDX_MARKOV_CLASSIC 0xff23
5361 #define IDX_MARKOV_THRESHOLD 't'
5362 #define IDX_MARKOV_HCSTAT 0xff24
5363 #define IDX_CPU_AFFINITY 0xff25
5364 #define IDX_OPENCL_DEVICES 'd'
5365 #define IDX_OPENCL_PLATFORMS 0xff72
5366 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5367 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5368 #define IDX_WORKLOAD_PROFILE 'w'
5369 #define IDX_KERNEL_ACCEL 'n'
5370 #define IDX_KERNEL_LOOPS 'u'
5371 #define IDX_GPU_TEMP_DISABLE 0xff29
5372 #define IDX_GPU_TEMP_ABORT 0xff30
5373 #define IDX_GPU_TEMP_RETAIN 0xff31
5374 #define IDX_POWERTUNE_ENABLE 0xff41
5375 #define IDX_LOGFILE_DISABLE 0xff51
5376 #define IDX_TRUECRYPT_KEYFILES 0xff52
5377 #define IDX_SCRYPT_TMTO 0xff61
5378 #define IDX_SEGMENT_SIZE 'c'
5379 #define IDX_SEPARATOR 'p'
5380 #define IDX_BITMAP_MIN 0xff70
5381 #define IDX_BITMAP_MAX 0xff71
5382 #define IDX_CUSTOM_CHARSET_1 '1'
5383 #define IDX_CUSTOM_CHARSET_2 '2'
5384 #define IDX_CUSTOM_CHARSET_3 '3'
5385 #define IDX_CUSTOM_CHARSET_4 '4'
5386
5387 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5388
5389 struct option long_options[] =
5390 {
5391 {"help", no_argument, 0, IDX_HELP},
5392 {"version", no_argument, 0, IDX_VERSION},
5393 {"quiet", no_argument, 0, IDX_QUIET},
5394 {"show", no_argument, 0, IDX_SHOW},
5395 {"left", no_argument, 0, IDX_LEFT},
5396 {"username", no_argument, 0, IDX_USERNAME},
5397 {"remove", no_argument, 0, IDX_REMOVE},
5398 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5399 {"skip", required_argument, 0, IDX_SKIP},
5400 {"limit", required_argument, 0, IDX_LIMIT},
5401 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5402 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5403 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5404 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5405 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5406 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5407 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5408 {"force", no_argument, 0, IDX_FORCE},
5409 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5410 {"restore", no_argument, 0, IDX_RESTORE},
5411 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5412 {"status", no_argument, 0, IDX_STATUS},
5413 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5414 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5415 {"loopback", no_argument, 0, IDX_LOOPBACK},
5416 {"weak-hash-threshold",
5417 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5418 {"session", required_argument, 0, IDX_SESSION},
5419 {"runtime", required_argument, 0, IDX_RUNTIME},
5420 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5421 {"generate-rules-func-min",
5422 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5423 {"generate-rules-func-max",
5424 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5425 {"generate-rules-seed",
5426 required_argument, 0, IDX_RP_GEN_SEED},
5427 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5428 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5429 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5430 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5431 {"rules-file", required_argument, 0, IDX_RP_FILE},
5432 {"outfile", required_argument, 0, IDX_OUTFILE},
5433 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5434 {"outfile-autohex-disable",
5435 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5436 {"outfile-check-timer",
5437 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5438 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5439 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5440 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5441 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5442 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5443 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5444 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5445 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5446 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5447 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5448 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5449 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5450 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5451 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5452 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5453 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5454 #ifdef HAVE_HWMON
5455 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5456 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5457 #ifdef HAVE_ADL
5458 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5459 #endif
5460 #endif // HAVE_HWMON
5461 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5462 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5463 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5464 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5465 // deprecated
5466 {"seperator", required_argument, 0, IDX_SEPARATOR},
5467 {"separator", required_argument, 0, IDX_SEPARATOR},
5468 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5469 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5470 {"increment", no_argument, 0, IDX_INCREMENT},
5471 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5472 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5473 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5474 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5475 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5476 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5477
5478 {0, 0, 0, 0}
5479 };
5480
5481 uint rp_files_cnt = 0;
5482
5483 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5484
5485 int option_index = 0;
5486 int c = -1;
5487
5488 optind = 1;
5489 optopt = 0;
5490
5491 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5492 {
5493 switch (c)
5494 {
5495 case IDX_HELP: usage = 1; break;
5496 case IDX_VERSION:
5497 case IDX_VERSION_LOWER: version = 1; break;
5498 case IDX_RESTORE: restore = 1; break;
5499 case IDX_SESSION: session = optarg; break;
5500 case IDX_SHOW: show = 1; break;
5501 case IDX_LEFT: left = 1; break;
5502 case '?': return (-1);
5503 }
5504 }
5505
5506 if (optopt != 0)
5507 {
5508 log_error ("ERROR: Invalid argument specified");
5509
5510 return (-1);
5511 }
5512
5513 /**
5514 * exit functions
5515 */
5516
5517 if (version)
5518 {
5519 log_info ("%s", VERSION_TAG);
5520
5521 return (0);
5522 }
5523
5524 if (usage)
5525 {
5526 usage_big_print (PROGNAME);
5527
5528 return (0);
5529 }
5530
5531 /**
5532 * session needs to be set, always!
5533 */
5534
5535 if (session == NULL) session = (char *) PROGNAME;
5536
5537 /**
5538 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
5539 */
5540
5541 char *exec_path = get_exec_path ();
5542
5543 #ifdef LINUX
5544
5545 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5546 char *resolved_exec_path = realpath (exec_path, NULL);
5547
5548 char *install_dir = get_install_dir (resolved_exec_path);
5549 char *profile_dir = NULL;
5550 char *session_dir = NULL;
5551 char *shared_dir = NULL;
5552
5553 if (strcmp (install_dir, resolved_install_folder) == 0)
5554 {
5555 struct passwd *pw = getpwuid (getuid ());
5556
5557 const char *homedir = pw->pw_dir;
5558
5559 profile_dir = get_profile_dir (homedir);
5560 session_dir = get_session_dir (profile_dir);
5561 shared_dir = strdup (SHARED_FOLDER);
5562
5563 mkdir (profile_dir, 0700);
5564 mkdir (session_dir, 0700);
5565 }
5566 else
5567 {
5568 profile_dir = install_dir;
5569 session_dir = install_dir;
5570 shared_dir = install_dir;
5571 }
5572
5573 myfree (resolved_install_folder);
5574 myfree (resolved_exec_path);
5575
5576 #else
5577
5578 char *install_dir = get_install_dir (exec_path);
5579 char *profile_dir = install_dir;
5580 char *session_dir = install_dir;
5581 char *shared_dir = install_dir;
5582
5583 #endif
5584
5585 data.install_dir = install_dir;
5586 data.profile_dir = profile_dir;
5587 data.session_dir = session_dir;
5588 data.shared_dir = shared_dir;
5589
5590 myfree (exec_path);
5591
5592 /**
5593 * kernel cache, we need to make sure folder exist
5594 */
5595
5596 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5597
5598 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5599
5600 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5601
5602 mkdir (kernels_folder, 0700);
5603
5604 myfree (kernels_folder);
5605
5606 /**
5607 * session
5608 */
5609
5610 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5611
5612 data.session = session;
5613
5614 char *eff_restore_file = (char *) mymalloc (session_size);
5615 char *new_restore_file = (char *) mymalloc (session_size);
5616
5617 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5618 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5619
5620 data.eff_restore_file = eff_restore_file;
5621 data.new_restore_file = new_restore_file;
5622
5623 if (((show == 1) || (left == 1)) && (restore == 1))
5624 {
5625 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5626 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5627
5628 return (-1);
5629 }
5630
5631 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
5632 if ((show == 1) || (left == 1))
5633 {
5634 restore_disable = 1;
5635
5636 restore = 0;
5637 }
5638
5639 data.restore_disable = restore_disable;
5640
5641 restore_data_t *rd = init_restore (argc, argv);
5642
5643 data.rd = rd;
5644
5645 /**
5646 * restore file
5647 */
5648
5649 if (restore == 1)
5650 {
5651 read_restore (eff_restore_file, rd);
5652
5653 if (rd->version_bin < RESTORE_MIN)
5654 {
5655 log_error ("ERROR: Incompatible restore-file version");
5656
5657 return (-1);
5658 }
5659
5660 myargc = rd->argc;
5661 myargv = rd->argv;
5662
5663 #ifdef _POSIX
5664 rd->pid = getpid ();
5665 #elif _WIN
5666 rd->pid = GetCurrentProcessId ();
5667 #endif
5668 }
5669
5670 uint hash_mode_chgd = 0;
5671 uint runtime_chgd = 0;
5672 uint kernel_loops_chgd = 0;
5673 uint kernel_accel_chgd = 0;
5674 uint attack_mode_chgd = 0;
5675 uint outfile_format_chgd = 0;
5676 uint rp_gen_seed_chgd = 0;
5677 uint remove_timer_chgd = 0;
5678 uint increment_min_chgd = 0;
5679 uint increment_max_chgd = 0;
5680 uint workload_profile_chgd = 0;
5681 uint opencl_vector_width_chgd = 0;
5682
5683 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5684 uint gpu_temp_retain_chgd = 0;
5685 uint gpu_temp_abort_chgd = 0;
5686 #endif
5687
5688 optind = 1;
5689 optopt = 0;
5690 option_index = 0;
5691
5692 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5693 {
5694 switch (c)
5695 {
5696 //case IDX_HELP: usage = 1; break;
5697 //case IDX_VERSION: version = 1; break;
5698 //case IDX_RESTORE: restore = 1; break;
5699 case IDX_QUIET: quiet = 1; break;
5700 //case IDX_SHOW: show = 1; break;
5701 case IDX_SHOW: break;
5702 //case IDX_LEFT: left = 1; break;
5703 case IDX_LEFT: break;
5704 case IDX_USERNAME: username = 1; break;
5705 case IDX_REMOVE: remove = 1; break;
5706 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5707 remove_timer_chgd = 1; break;
5708 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5709 case IDX_POTFILE_PATH: potfile_path = optarg; break;
5710 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5711 case IDX_DEBUG_FILE: debug_file = optarg; break;
5712 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5713 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5714 case IDX_FORCE: force = 1; break;
5715 case IDX_SKIP: skip = atoll (optarg); break;
5716 case IDX_LIMIT: limit = atoll (optarg); break;
5717 case IDX_KEYSPACE: keyspace = 1; break;
5718 case IDX_BENCHMARK: benchmark = 1; break;
5719 case IDX_RESTORE: break;
5720 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5721 case IDX_STATUS: status = 1; break;
5722 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5723 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5724 case IDX_LOOPBACK: loopback = 1; break;
5725 case IDX_WEAK_HASH_THRESHOLD:
5726 weak_hash_threshold = atoi (optarg); break;
5727 //case IDX_SESSION: session = optarg; break;
5728 case IDX_SESSION: break;
5729 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5730 hash_mode_chgd = 1; break;
5731 case IDX_RUNTIME: runtime = atoi (optarg);
5732 runtime_chgd = 1; break;
5733 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5734 attack_mode_chgd = 1; break;
5735 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5736 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5737 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5738 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5739 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5740 rp_gen_seed_chgd = 1; break;
5741 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5742 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5743 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5744 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5745 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5746 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5747 case IDX_OUTFILE: outfile = optarg; break;
5748 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5749 outfile_format_chgd = 1; break;
5750 case IDX_OUTFILE_AUTOHEX_DISABLE:
5751 outfile_autohex = 0; break;
5752 case IDX_OUTFILE_CHECK_TIMER:
5753 outfile_check_timer = atoi (optarg); break;
5754 case IDX_HEX_CHARSET: hex_charset = 1; break;
5755 case IDX_HEX_SALT: hex_salt = 1; break;
5756 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5757 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5758 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5759 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5760 case IDX_OPENCL_DEVICE_TYPES:
5761 opencl_device_types = optarg; break;
5762 case IDX_OPENCL_VECTOR_WIDTH:
5763 opencl_vector_width = atoi (optarg);
5764 opencl_vector_width_chgd = 1; break;
5765 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
5766 workload_profile_chgd = 1; break;
5767 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5768 kernel_accel_chgd = 1; break;
5769 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5770 kernel_loops_chgd = 1; break;
5771 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5772 #ifdef HAVE_HWMON
5773 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5774 #ifdef HAVE_ADL
5775 gpu_temp_abort_chgd = 1;
5776 #endif
5777 break;
5778 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5779 #ifdef HAVE_ADL
5780 gpu_temp_retain_chgd = 1;
5781 #endif
5782 break;
5783 #ifdef HAVE_ADL
5784 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5785 #endif
5786 #endif // HAVE_HWMON
5787 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5788 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5789 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5790 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5791 case IDX_SEPARATOR: separator = optarg[0]; break;
5792 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5793 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5794 case IDX_INCREMENT: increment = 1; break;
5795 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5796 increment_min_chgd = 1; break;
5797 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5798 increment_max_chgd = 1; break;
5799 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5800 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5801 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5802 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5803
5804 default:
5805 log_error ("ERROR: Invalid argument specified");
5806 return (-1);
5807 }
5808 }
5809
5810 if (optopt != 0)
5811 {
5812 log_error ("ERROR: Invalid argument specified");
5813
5814 return (-1);
5815 }
5816
5817 /**
5818 * Inform user things getting started,
5819 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5820 * - we do not need to check algorithm_pos
5821 */
5822
5823 if (quiet == 0)
5824 {
5825 if (benchmark == 1)
5826 {
5827 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
5828 log_info ("");
5829 }
5830 else if (restore == 1)
5831 {
5832 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
5833 log_info ("");
5834 }
5835 else
5836 {
5837 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
5838 log_info ("");
5839 }
5840 }
5841
5842 /**
5843 * sanity check
5844 */
5845
5846 if (attack_mode > 7)
5847 {
5848 log_error ("ERROR: Invalid attack-mode specified");
5849
5850 return (-1);
5851 }
5852
5853 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5854 {
5855 log_error ("ERROR: Invalid runtime specified");
5856
5857 return (-1);
5858 }
5859
5860 if (hash_mode_chgd && hash_mode > 13600) // just added to remove compiler warnings for hash_mode_chgd
5861 {
5862 log_error ("ERROR: Invalid hash-type specified");
5863
5864 return (-1);
5865 }
5866
5867 // renamed hash modes
5868
5869 if (hash_mode_chgd)
5870 {
5871 int n = -1;
5872
5873 switch (hash_mode)
5874 {
5875 case 123: n = 124;
5876 break;
5877 }
5878
5879 if (n >= 0)
5880 {
5881 log_error ("Old -m specified, use -m %d instead", n);
5882
5883 return (-1);
5884 }
5885 }
5886
5887 if (username == 1)
5888 {
5889 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
5890 {
5891 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5892
5893 return (-1);
5894 }
5895 }
5896
5897 if (outfile_format > 16)
5898 {
5899 log_error ("ERROR: Invalid outfile-format specified");
5900
5901 return (-1);
5902 }
5903
5904 if (left == 1)
5905 {
5906 if (outfile_format_chgd == 1)
5907 {
5908 if (outfile_format > 1)
5909 {
5910 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
5911
5912 return (-1);
5913 }
5914 }
5915 else
5916 {
5917 outfile_format = OUTFILE_FMT_HASH;
5918 }
5919 }
5920
5921 if (show == 1)
5922 {
5923 if (outfile_format_chgd == 1)
5924 {
5925 if ((outfile_format > 7) && (outfile_format < 16))
5926 {
5927 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
5928
5929 return (-1);
5930 }
5931 }
5932 }
5933
5934 if (increment_min < INCREMENT_MIN)
5935 {
5936 log_error ("ERROR: Invalid increment-min specified");
5937
5938 return (-1);
5939 }
5940
5941 if (increment_max > INCREMENT_MAX)
5942 {
5943 log_error ("ERROR: Invalid increment-max specified");
5944
5945 return (-1);
5946 }
5947
5948 if (increment_min > increment_max)
5949 {
5950 log_error ("ERROR: Invalid increment-min specified");
5951
5952 return (-1);
5953 }
5954
5955 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
5956 {
5957 log_error ("ERROR: increment is not allowed in attack-mode 0");
5958
5959 return (-1);
5960 }
5961
5962 if ((increment == 0) && (increment_min_chgd == 1))
5963 {
5964 log_error ("ERROR: increment-min is only supported together with increment switch");
5965
5966 return (-1);
5967 }
5968
5969 if ((increment == 0) && (increment_max_chgd == 1))
5970 {
5971 log_error ("ERROR: increment-max is only supported together with increment switch");
5972
5973 return (-1);
5974 }
5975
5976 if (rp_files_cnt && rp_gen)
5977 {
5978 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
5979
5980 return (-1);
5981 }
5982
5983 if (rp_files_cnt || rp_gen)
5984 {
5985 if (attack_mode != ATTACK_MODE_STRAIGHT)
5986 {
5987 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
5988
5989 return (-1);
5990 }
5991 }
5992
5993 if (rp_gen_func_min > rp_gen_func_max)
5994 {
5995 log_error ("ERROR: Invalid rp-gen-func-min specified");
5996
5997 return (-1);
5998 }
5999
6000 if (kernel_accel_chgd == 1)
6001 {
6002 if (kernel_accel < 1)
6003 {
6004 log_error ("ERROR: Invalid kernel-accel specified");
6005
6006 return (-1);
6007 }
6008
6009 if (kernel_accel > 1024)
6010 {
6011 log_error ("ERROR: Invalid kernel-accel specified");
6012
6013 return (-1);
6014 }
6015 }
6016
6017 if (kernel_loops_chgd == 1)
6018 {
6019 if (kernel_loops < 1)
6020 {
6021 log_error ("ERROR: Invalid kernel-loops specified");
6022
6023 return (-1);
6024 }
6025
6026 if (kernel_loops > 1024)
6027 {
6028 log_error ("ERROR: Invalid kernel-loops specified");
6029
6030 return (-1);
6031 }
6032 }
6033
6034 if ((workload_profile < 1) || (workload_profile > 3))
6035 {
6036 log_error ("ERROR: workload-profile %i not available", workload_profile);
6037
6038 return (-1);
6039 }
6040
6041 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6042 {
6043 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6044
6045 return (-1);
6046 }
6047
6048 if (show == 1 || left == 1)
6049 {
6050 attack_mode = ATTACK_MODE_NONE;
6051
6052 if (remove == 1)
6053 {
6054 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6055
6056 return (-1);
6057 }
6058
6059 if (potfile_disable == 1)
6060 {
6061 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6062
6063 return (-1);
6064 }
6065 }
6066
6067 uint attack_kern = ATTACK_KERN_NONE;
6068
6069 switch (attack_mode)
6070 {
6071 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6072 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6073 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6074 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6075 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6076 }
6077
6078 if (benchmark == 0)
6079 {
6080 if (keyspace == 1)
6081 {
6082 int num_additional_params = 1;
6083
6084 if (attack_kern == ATTACK_KERN_COMBI)
6085 {
6086 num_additional_params = 2;
6087 }
6088
6089 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6090
6091 if (keyspace_wordlist_specified == 0) optind--;
6092 }
6093
6094 if (attack_kern == ATTACK_KERN_NONE)
6095 {
6096 if ((optind + 1) != myargc)
6097 {
6098 usage_mini_print (myargv[0]);
6099
6100 return (-1);
6101 }
6102 }
6103 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6104 {
6105 if ((optind + 1) > myargc)
6106 {
6107 usage_mini_print (myargv[0]);
6108
6109 return (-1);
6110 }
6111 }
6112 else if (attack_kern == ATTACK_KERN_COMBI)
6113 {
6114 if ((optind + 3) != myargc)
6115 {
6116 usage_mini_print (myargv[0]);
6117
6118 return (-1);
6119 }
6120 }
6121 else if (attack_kern == ATTACK_KERN_BF)
6122 {
6123 if ((optind + 1) > myargc)
6124 {
6125 usage_mini_print (myargv[0]);
6126
6127 return (-1);
6128 }
6129 }
6130 else
6131 {
6132 usage_mini_print (myargv[0]);
6133
6134 return (-1);
6135 }
6136 }
6137 else
6138 {
6139 if (myargv[optind] != 0)
6140 {
6141 log_error ("ERROR: Invalid argument for benchmark mode specified");
6142
6143 return (-1);
6144 }
6145
6146 if (attack_mode_chgd == 1)
6147 {
6148 if (attack_mode != ATTACK_MODE_BF)
6149 {
6150 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6151
6152 return (-1);
6153 }
6154 }
6155 }
6156
6157 if (skip != 0 && limit != 0)
6158 {
6159 limit += skip;
6160 }
6161
6162 if (keyspace == 1)
6163 {
6164 if (show == 1)
6165 {
6166 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6167
6168 return (-1);
6169 }
6170 else if (left == 1)
6171 {
6172 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6173
6174 return (-1);
6175 }
6176
6177 potfile_disable = 1;
6178
6179 restore_disable = 1;
6180
6181 restore = 0;
6182
6183 weak_hash_threshold = 0;
6184
6185 quiet = 1;
6186 }
6187
6188 if (remove_timer_chgd == 1)
6189 {
6190 if (remove == 0)
6191 {
6192 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6193
6194 return (-1);
6195 }
6196
6197 if (remove_timer < 1)
6198 {
6199 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6200
6201 return (-1);
6202 }
6203 }
6204
6205 if (loopback == 1)
6206 {
6207 if (attack_mode == ATTACK_MODE_STRAIGHT)
6208 {
6209 if ((rp_files_cnt == 0) && (rp_gen == 0))
6210 {
6211 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6212
6213 return (-1);
6214 }
6215 }
6216 else
6217 {
6218 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6219
6220 return (-1);
6221 }
6222 }
6223
6224 if (debug_mode > 0)
6225 {
6226 if (attack_mode != ATTACK_MODE_STRAIGHT)
6227 {
6228 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6229
6230 return (-1);
6231 }
6232
6233 if ((rp_files_cnt == 0) && (rp_gen == 0))
6234 {
6235 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6236
6237 return (-1);
6238 }
6239 }
6240
6241 if (debug_mode > 4)
6242 {
6243 log_error ("ERROR: Invalid debug-mode specified");
6244
6245 return (-1);
6246 }
6247
6248 if (debug_file != NULL)
6249 {
6250 if (debug_mode < 1)
6251 {
6252 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6253
6254 return (-1);
6255 }
6256 }
6257
6258 if (induction_dir != NULL)
6259 {
6260 if (attack_mode == ATTACK_MODE_BF)
6261 {
6262 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6263
6264 return (-1);
6265 }
6266 }
6267
6268 if (attack_mode != ATTACK_MODE_STRAIGHT)
6269 {
6270 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6271 {
6272 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6273
6274 return (-1);
6275 }
6276
6277 weak_hash_threshold = 0;
6278 }
6279
6280 /**
6281 * induction directory
6282 */
6283
6284 char *induction_directory = NULL;
6285
6286 if (attack_mode != ATTACK_MODE_BF)
6287 {
6288 if (induction_dir == NULL)
6289 {
6290 induction_directory = (char *) mymalloc (session_size);
6291
6292 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6293
6294 // create induction folder if it does not already exist
6295
6296 if (keyspace == 0)
6297 {
6298 if (rmdir (induction_directory) == -1)
6299 {
6300 if (errno == ENOENT)
6301 {
6302 // good, we can ignore
6303 }
6304 else if (errno == ENOTEMPTY)
6305 {
6306 char *induction_directory_mv = (char *) mymalloc (session_size);
6307
6308 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6309
6310 if (rename (induction_directory, induction_directory_mv) != 0)
6311 {
6312 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6313
6314 return (-1);
6315 }
6316 }
6317 else
6318 {
6319 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6320
6321 return (-1);
6322 }
6323 }
6324
6325 if (mkdir (induction_directory, 0700) == -1)
6326 {
6327 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6328
6329 return (-1);
6330 }
6331 }
6332 }
6333 else
6334 {
6335 induction_directory = induction_dir;
6336 }
6337 }
6338
6339 data.induction_directory = induction_directory;
6340
6341 /**
6342 * loopback
6343 */
6344
6345 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6346
6347 char *loopback_file = (char *) mymalloc (loopback_size);
6348
6349 /**
6350 * tuning db
6351 */
6352
6353 char tuning_db_file[256] = { 0 };
6354
6355 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6356
6357 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6358
6359 /**
6360 * outfile-check directory
6361 */
6362
6363 char *outfile_check_directory = NULL;
6364
6365 if (outfile_check_dir == NULL)
6366 {
6367 outfile_check_directory = (char *) mymalloc (session_size);
6368
6369 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6370 }
6371 else
6372 {
6373 outfile_check_directory = outfile_check_dir;
6374 }
6375
6376 data.outfile_check_directory = outfile_check_directory;
6377
6378 if (keyspace == 0)
6379 {
6380 struct stat outfile_check_stat;
6381
6382 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6383 {
6384 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6385
6386 if (is_dir == 0)
6387 {
6388 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6389
6390 return (-1);
6391 }
6392 }
6393 else if (outfile_check_dir == NULL)
6394 {
6395 if (mkdir (outfile_check_directory, 0700) == -1)
6396 {
6397 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6398
6399 return (-1);
6400 }
6401 }
6402 }
6403
6404 /**
6405 * special other stuff
6406 */
6407
6408 if (hash_mode == 9710)
6409 {
6410 outfile_format = 5;
6411 outfile_format_chgd = 1;
6412 }
6413
6414 if (hash_mode == 9810)
6415 {
6416 outfile_format = 5;
6417 outfile_format_chgd = 1;
6418 }
6419
6420 if (hash_mode == 10410)
6421 {
6422 outfile_format = 5;
6423 outfile_format_chgd = 1;
6424 }
6425
6426 /**
6427 * store stuff
6428 */
6429
6430 data.hash_mode = hash_mode;
6431 data.restore = restore;
6432 data.restore_timer = restore_timer;
6433 data.restore_disable = restore_disable;
6434 data.status = status;
6435 data.status_timer = status_timer;
6436 data.status_automat = status_automat;
6437 data.loopback = loopback;
6438 data.runtime = runtime;
6439 data.remove = remove;
6440 data.remove_timer = remove_timer;
6441 data.debug_mode = debug_mode;
6442 data.debug_file = debug_file;
6443 data.username = username;
6444 data.quiet = quiet;
6445 data.outfile = outfile;
6446 data.outfile_format = outfile_format;
6447 data.outfile_autohex = outfile_autohex;
6448 data.hex_charset = hex_charset;
6449 data.hex_salt = hex_salt;
6450 data.hex_wordlist = hex_wordlist;
6451 data.separator = separator;
6452 data.rp_files = rp_files;
6453 data.rp_files_cnt = rp_files_cnt;
6454 data.rp_gen = rp_gen;
6455 data.rp_gen_seed = rp_gen_seed;
6456 data.force = force;
6457 data.benchmark = benchmark;
6458 data.skip = skip;
6459 data.limit = limit;
6460 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6461 data.powertune_enable = powertune_enable;
6462 #endif
6463 data.logfile_disable = logfile_disable;
6464 data.truecrypt_keyfiles = truecrypt_keyfiles;
6465 data.scrypt_tmto = scrypt_tmto;
6466 data.workload_profile = workload_profile;
6467
6468 /**
6469 * cpu affinity
6470 */
6471
6472 if (cpu_affinity)
6473 {
6474 set_cpu_affinity (cpu_affinity);
6475 }
6476
6477 if (rp_gen_seed_chgd == 0)
6478 {
6479 srand (proc_start);
6480 }
6481 else
6482 {
6483 srand (rp_gen_seed);
6484 }
6485
6486 /**
6487 * logfile init
6488 */
6489
6490 if (logfile_disable == 0)
6491 {
6492 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6493
6494 char *logfile = (char *) mymalloc (logfile_size);
6495
6496 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6497
6498 data.logfile = logfile;
6499
6500 char *topid = logfile_generate_topid ();
6501
6502 data.topid = topid;
6503 }
6504
6505 // logfile_append() checks for logfile_disable internally to make it easier from here
6506
6507 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6508 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6509 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6510 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6511 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6512 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6513 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6514 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6515 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6516 #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));
6517
6518 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6519 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6520 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6521 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6522 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6523 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6524 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6525 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6526
6527 logfile_top_msg ("START");
6528
6529 logfile_top_uint (attack_mode);
6530 logfile_top_uint (attack_kern);
6531 logfile_top_uint (benchmark);
6532 logfile_top_uint (bitmap_min);
6533 logfile_top_uint (bitmap_max);
6534 logfile_top_uint (debug_mode);
6535 logfile_top_uint (force);
6536 logfile_top_uint (kernel_accel);
6537 logfile_top_uint (kernel_loops);
6538 logfile_top_uint (gpu_temp_disable);
6539 #ifdef HAVE_HWMON
6540 logfile_top_uint (gpu_temp_abort);
6541 logfile_top_uint (gpu_temp_retain);
6542 #endif
6543 logfile_top_uint (hash_mode);
6544 logfile_top_uint (hex_charset);
6545 logfile_top_uint (hex_salt);
6546 logfile_top_uint (hex_wordlist);
6547 logfile_top_uint (increment);
6548 logfile_top_uint (increment_max);
6549 logfile_top_uint (increment_min);
6550 logfile_top_uint (keyspace);
6551 logfile_top_uint (left);
6552 logfile_top_uint (logfile_disable);
6553 logfile_top_uint (loopback);
6554 logfile_top_uint (markov_classic);
6555 logfile_top_uint (markov_disable);
6556 logfile_top_uint (markov_threshold);
6557 logfile_top_uint (outfile_autohex);
6558 logfile_top_uint (outfile_check_timer);
6559 logfile_top_uint (outfile_format);
6560 logfile_top_uint (potfile_disable);
6561 logfile_top_string (potfile_path);
6562 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6563 logfile_top_uint (powertune_enable);
6564 #endif
6565 logfile_top_uint (scrypt_tmto);
6566 logfile_top_uint (quiet);
6567 logfile_top_uint (remove);
6568 logfile_top_uint (remove_timer);
6569 logfile_top_uint (restore);
6570 logfile_top_uint (restore_disable);
6571 logfile_top_uint (restore_timer);
6572 logfile_top_uint (rp_gen);
6573 logfile_top_uint (rp_gen_func_max);
6574 logfile_top_uint (rp_gen_func_min);
6575 logfile_top_uint (rp_gen_seed);
6576 logfile_top_uint (runtime);
6577 logfile_top_uint (segment_size);
6578 logfile_top_uint (show);
6579 logfile_top_uint (status);
6580 logfile_top_uint (status_automat);
6581 logfile_top_uint (status_timer);
6582 logfile_top_uint (usage);
6583 logfile_top_uint (username);
6584 logfile_top_uint (version);
6585 logfile_top_uint (weak_hash_threshold);
6586 logfile_top_uint (workload_profile);
6587 logfile_top_uint64 (limit);
6588 logfile_top_uint64 (skip);
6589 logfile_top_char (separator);
6590 logfile_top_string (cpu_affinity);
6591 logfile_top_string (custom_charset_1);
6592 logfile_top_string (custom_charset_2);
6593 logfile_top_string (custom_charset_3);
6594 logfile_top_string (custom_charset_4);
6595 logfile_top_string (debug_file);
6596 logfile_top_string (opencl_devices);
6597 logfile_top_string (opencl_platforms);
6598 logfile_top_string (opencl_device_types);
6599 logfile_top_uint (opencl_vector_width);
6600 logfile_top_string (induction_dir);
6601 logfile_top_string (markov_hcstat);
6602 logfile_top_string (outfile);
6603 logfile_top_string (outfile_check_dir);
6604 logfile_top_string (rule_buf_l);
6605 logfile_top_string (rule_buf_r);
6606 logfile_top_string (session);
6607 logfile_top_string (truecrypt_keyfiles);
6608
6609 /**
6610 * Init OpenCL library loader
6611 */
6612
6613 if (keyspace == 0)
6614 {
6615 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6616
6617 ocl_init (ocl);
6618
6619 data.ocl = ocl;
6620 }
6621
6622 /**
6623 * OpenCL platform selection
6624 */
6625
6626 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6627
6628 /**
6629 * OpenCL device selection
6630 */
6631
6632 u32 devices_filter = setup_devices_filter (opencl_devices);
6633
6634 /**
6635 * OpenCL device type selection
6636 */
6637
6638 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6639
6640 /**
6641 * benchmark
6642 */
6643
6644 if (benchmark == 1)
6645 {
6646 /**
6647 * disable useless stuff for benchmark
6648 */
6649
6650 status_timer = 0;
6651 restore_timer = 0;
6652 restore_disable = 1;
6653 potfile_disable = 1;
6654 weak_hash_threshold = 0;
6655 gpu_temp_disable = 1;
6656
6657 data.status_timer = status_timer;
6658 data.restore_timer = restore_timer;
6659 data.restore_disable = restore_disable;
6660
6661 /**
6662 * force attack mode to be bruteforce
6663 */
6664
6665 attack_mode = ATTACK_MODE_BF;
6666 attack_kern = ATTACK_KERN_BF;
6667
6668 if (workload_profile_chgd == 0)
6669 {
6670 workload_profile = 3;
6671
6672 data.workload_profile = workload_profile;
6673 }
6674 }
6675
6676 /**
6677 * config
6678 */
6679
6680 uint hash_type = 0;
6681 uint salt_type = 0;
6682 uint attack_exec = 0;
6683 uint opts_type = 0;
6684 uint kern_type = 0;
6685 uint dgst_size = 0;
6686 uint esalt_size = 0;
6687 uint opti_type = 0;
6688 uint dgst_pos0 = -1;
6689 uint dgst_pos1 = -1;
6690 uint dgst_pos2 = -1;
6691 uint dgst_pos3 = -1;
6692
6693 int (*parse_func) (char *, uint, hash_t *);
6694 int (*sort_by_digest) (const void *, const void *);
6695
6696 uint algorithm_pos = 0;
6697 uint algorithm_max = 1;
6698
6699 uint *algorithms = default_benchmark_algorithms;
6700
6701 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6702
6703 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6704 {
6705 /*
6706 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6707 * the following algos are skipped entirely
6708 */
6709
6710 if (algorithm_pos > 0)
6711 {
6712 local_free (rd);
6713
6714 rd = init_restore (argc, argv);
6715
6716 data.rd = rd;
6717 }
6718
6719 /**
6720 * update hash_mode in case of multihash benchmark
6721 */
6722
6723 if (benchmark == 1)
6724 {
6725 if (hash_mode_chgd == 0)
6726 {
6727 hash_mode = algorithms[algorithm_pos];
6728
6729 data.hash_mode = hash_mode;
6730 }
6731
6732 quiet = 1;
6733
6734 data.quiet = quiet;
6735 }
6736
6737 switch (hash_mode)
6738 {
6739 case 0: hash_type = HASH_TYPE_MD5;
6740 salt_type = SALT_TYPE_NONE;
6741 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6742 opts_type = OPTS_TYPE_PT_GENERATE_LE
6743 | OPTS_TYPE_PT_ADD80
6744 | OPTS_TYPE_PT_ADDBITS14;
6745 kern_type = KERN_TYPE_MD5;
6746 dgst_size = DGST_SIZE_4_4;
6747 parse_func = md5_parse_hash;
6748 sort_by_digest = sort_by_digest_4_4;
6749 opti_type = OPTI_TYPE_ZERO_BYTE
6750 | OPTI_TYPE_PRECOMPUTE_INIT
6751 | OPTI_TYPE_PRECOMPUTE_MERKLE
6752 | OPTI_TYPE_MEET_IN_MIDDLE
6753 | OPTI_TYPE_EARLY_SKIP
6754 | OPTI_TYPE_NOT_ITERATED
6755 | OPTI_TYPE_NOT_SALTED
6756 | OPTI_TYPE_RAW_HASH;
6757 dgst_pos0 = 0;
6758 dgst_pos1 = 3;
6759 dgst_pos2 = 2;
6760 dgst_pos3 = 1;
6761 break;
6762
6763 case 10: hash_type = HASH_TYPE_MD5;
6764 salt_type = SALT_TYPE_INTERN;
6765 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6766 opts_type = OPTS_TYPE_PT_GENERATE_LE
6767 | OPTS_TYPE_ST_ADD80
6768 | OPTS_TYPE_ST_ADDBITS14;
6769 kern_type = KERN_TYPE_MD5_PWSLT;
6770 dgst_size = DGST_SIZE_4_4;
6771 parse_func = md5s_parse_hash;
6772 sort_by_digest = sort_by_digest_4_4;
6773 opti_type = OPTI_TYPE_ZERO_BYTE
6774 | OPTI_TYPE_PRECOMPUTE_INIT
6775 | OPTI_TYPE_PRECOMPUTE_MERKLE
6776 | OPTI_TYPE_MEET_IN_MIDDLE
6777 | OPTI_TYPE_EARLY_SKIP
6778 | OPTI_TYPE_NOT_ITERATED
6779 | OPTI_TYPE_APPENDED_SALT
6780 | OPTI_TYPE_RAW_HASH;
6781 dgst_pos0 = 0;
6782 dgst_pos1 = 3;
6783 dgst_pos2 = 2;
6784 dgst_pos3 = 1;
6785 break;
6786
6787 case 11: hash_type = HASH_TYPE_MD5;
6788 salt_type = SALT_TYPE_INTERN;
6789 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6790 opts_type = OPTS_TYPE_PT_GENERATE_LE
6791 | OPTS_TYPE_ST_ADD80
6792 | OPTS_TYPE_ST_ADDBITS14;
6793 kern_type = KERN_TYPE_MD5_PWSLT;
6794 dgst_size = DGST_SIZE_4_4;
6795 parse_func = joomla_parse_hash;
6796 sort_by_digest = sort_by_digest_4_4;
6797 opti_type = OPTI_TYPE_ZERO_BYTE
6798 | OPTI_TYPE_PRECOMPUTE_INIT
6799 | OPTI_TYPE_PRECOMPUTE_MERKLE
6800 | OPTI_TYPE_MEET_IN_MIDDLE
6801 | OPTI_TYPE_EARLY_SKIP
6802 | OPTI_TYPE_NOT_ITERATED
6803 | OPTI_TYPE_APPENDED_SALT
6804 | OPTI_TYPE_RAW_HASH;
6805 dgst_pos0 = 0;
6806 dgst_pos1 = 3;
6807 dgst_pos2 = 2;
6808 dgst_pos3 = 1;
6809 break;
6810
6811 case 12: hash_type = HASH_TYPE_MD5;
6812 salt_type = SALT_TYPE_INTERN;
6813 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6814 opts_type = OPTS_TYPE_PT_GENERATE_LE
6815 | OPTS_TYPE_ST_ADD80
6816 | OPTS_TYPE_ST_ADDBITS14;
6817 kern_type = KERN_TYPE_MD5_PWSLT;
6818 dgst_size = DGST_SIZE_4_4;
6819 parse_func = postgresql_parse_hash;
6820 sort_by_digest = sort_by_digest_4_4;
6821 opti_type = OPTI_TYPE_ZERO_BYTE
6822 | OPTI_TYPE_PRECOMPUTE_INIT
6823 | OPTI_TYPE_PRECOMPUTE_MERKLE
6824 | OPTI_TYPE_MEET_IN_MIDDLE
6825 | OPTI_TYPE_EARLY_SKIP
6826 | OPTI_TYPE_NOT_ITERATED
6827 | OPTI_TYPE_APPENDED_SALT
6828 | OPTI_TYPE_RAW_HASH;
6829 dgst_pos0 = 0;
6830 dgst_pos1 = 3;
6831 dgst_pos2 = 2;
6832 dgst_pos3 = 1;
6833 break;
6834
6835 case 20: hash_type = HASH_TYPE_MD5;
6836 salt_type = SALT_TYPE_INTERN;
6837 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6838 opts_type = OPTS_TYPE_PT_GENERATE_LE
6839 | OPTS_TYPE_PT_ADD80
6840 | OPTS_TYPE_PT_ADDBITS14;
6841 kern_type = KERN_TYPE_MD5_SLTPW;
6842 dgst_size = DGST_SIZE_4_4;
6843 parse_func = md5s_parse_hash;
6844 sort_by_digest = sort_by_digest_4_4;
6845 opti_type = OPTI_TYPE_ZERO_BYTE
6846 | OPTI_TYPE_PRECOMPUTE_INIT
6847 | OPTI_TYPE_PRECOMPUTE_MERKLE
6848 | OPTI_TYPE_EARLY_SKIP
6849 | OPTI_TYPE_NOT_ITERATED
6850 | OPTI_TYPE_PREPENDED_SALT
6851 | OPTI_TYPE_RAW_HASH;
6852 dgst_pos0 = 0;
6853 dgst_pos1 = 3;
6854 dgst_pos2 = 2;
6855 dgst_pos3 = 1;
6856 break;
6857
6858 case 21: hash_type = HASH_TYPE_MD5;
6859 salt_type = SALT_TYPE_INTERN;
6860 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6861 opts_type = OPTS_TYPE_PT_GENERATE_LE
6862 | OPTS_TYPE_PT_ADD80
6863 | OPTS_TYPE_PT_ADDBITS14;
6864 kern_type = KERN_TYPE_MD5_SLTPW;
6865 dgst_size = DGST_SIZE_4_4;
6866 parse_func = osc_parse_hash;
6867 sort_by_digest = sort_by_digest_4_4;
6868 opti_type = OPTI_TYPE_ZERO_BYTE
6869 | OPTI_TYPE_PRECOMPUTE_INIT
6870 | OPTI_TYPE_PRECOMPUTE_MERKLE
6871 | OPTI_TYPE_EARLY_SKIP
6872 | OPTI_TYPE_NOT_ITERATED
6873 | OPTI_TYPE_PREPENDED_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 22: hash_type = HASH_TYPE_MD5;
6882 salt_type = SALT_TYPE_EMBEDDED;
6883 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6884 opts_type = OPTS_TYPE_PT_GENERATE_LE
6885 | OPTS_TYPE_PT_ADD80
6886 | OPTS_TYPE_PT_ADDBITS14;
6887 kern_type = KERN_TYPE_MD5_SLTPW;
6888 dgst_size = DGST_SIZE_4_4;
6889 parse_func = netscreen_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_EARLY_SKIP
6895 | OPTI_TYPE_NOT_ITERATED
6896 | OPTI_TYPE_PREPENDED_SALT
6897 | OPTI_TYPE_RAW_HASH;
6898 dgst_pos0 = 0;
6899 dgst_pos1 = 3;
6900 dgst_pos2 = 2;
6901 dgst_pos3 = 1;
6902 break;
6903
6904 case 23: hash_type = HASH_TYPE_MD5;
6905 salt_type = SALT_TYPE_EMBEDDED;
6906 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6907 opts_type = OPTS_TYPE_PT_GENERATE_LE
6908 | OPTS_TYPE_PT_ADD80
6909 | OPTS_TYPE_PT_ADDBITS14;
6910 kern_type = KERN_TYPE_MD5_SLTPW;
6911 dgst_size = DGST_SIZE_4_4;
6912 parse_func = skype_parse_hash;
6913 sort_by_digest = sort_by_digest_4_4;
6914 opti_type = OPTI_TYPE_ZERO_BYTE
6915 | OPTI_TYPE_PRECOMPUTE_INIT
6916 | OPTI_TYPE_PRECOMPUTE_MERKLE
6917 | OPTI_TYPE_EARLY_SKIP
6918 | OPTI_TYPE_NOT_ITERATED
6919 | OPTI_TYPE_PREPENDED_SALT
6920 | OPTI_TYPE_RAW_HASH;
6921 dgst_pos0 = 0;
6922 dgst_pos1 = 3;
6923 dgst_pos2 = 2;
6924 dgst_pos3 = 1;
6925 break;
6926
6927 case 30: hash_type = HASH_TYPE_MD5;
6928 salt_type = SALT_TYPE_INTERN;
6929 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6930 opts_type = OPTS_TYPE_PT_GENERATE_LE
6931 | OPTS_TYPE_PT_UNICODE
6932 | OPTS_TYPE_ST_ADD80
6933 | OPTS_TYPE_ST_ADDBITS14;
6934 kern_type = KERN_TYPE_MD5_PWUSLT;
6935 dgst_size = DGST_SIZE_4_4;
6936 parse_func = md5s_parse_hash;
6937 sort_by_digest = sort_by_digest_4_4;
6938 opti_type = OPTI_TYPE_ZERO_BYTE
6939 | OPTI_TYPE_PRECOMPUTE_INIT
6940 | OPTI_TYPE_PRECOMPUTE_MERKLE
6941 | OPTI_TYPE_MEET_IN_MIDDLE
6942 | OPTI_TYPE_EARLY_SKIP
6943 | OPTI_TYPE_NOT_ITERATED
6944 | OPTI_TYPE_APPENDED_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 40: 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 | OPTS_TYPE_PT_UNICODE;
6959 kern_type = KERN_TYPE_MD5_SLTPWU;
6960 dgst_size = DGST_SIZE_4_4;
6961 parse_func = md5s_parse_hash;
6962 sort_by_digest = sort_by_digest_4_4;
6963 opti_type = OPTI_TYPE_ZERO_BYTE
6964 | OPTI_TYPE_PRECOMPUTE_INIT
6965 | OPTI_TYPE_PRECOMPUTE_MERKLE
6966 | OPTI_TYPE_EARLY_SKIP
6967 | OPTI_TYPE_NOT_ITERATED
6968 | OPTI_TYPE_PREPENDED_SALT
6969 | OPTI_TYPE_RAW_HASH;
6970 dgst_pos0 = 0;
6971 dgst_pos1 = 3;
6972 dgst_pos2 = 2;
6973 dgst_pos3 = 1;
6974 break;
6975
6976 case 50: hash_type = HASH_TYPE_MD5;
6977 salt_type = SALT_TYPE_INTERN;
6978 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6979 opts_type = OPTS_TYPE_PT_GENERATE_LE
6980 | OPTS_TYPE_ST_ADD80
6981 | OPTS_TYPE_ST_ADDBITS14;
6982 kern_type = KERN_TYPE_HMACMD5_PW;
6983 dgst_size = DGST_SIZE_4_4;
6984 parse_func = hmacmd5_parse_hash;
6985 sort_by_digest = sort_by_digest_4_4;
6986 opti_type = OPTI_TYPE_ZERO_BYTE
6987 | OPTI_TYPE_NOT_ITERATED;
6988 dgst_pos0 = 0;
6989 dgst_pos1 = 3;
6990 dgst_pos2 = 2;
6991 dgst_pos3 = 1;
6992 break;
6993
6994 case 60: hash_type = HASH_TYPE_MD5;
6995 salt_type = SALT_TYPE_INTERN;
6996 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6997 opts_type = OPTS_TYPE_PT_GENERATE_LE
6998 | OPTS_TYPE_PT_ADD80
6999 | OPTS_TYPE_PT_ADDBITS14;
7000 kern_type = KERN_TYPE_HMACMD5_SLT;
7001 dgst_size = DGST_SIZE_4_4;
7002 parse_func = hmacmd5_parse_hash;
7003 sort_by_digest = sort_by_digest_4_4;
7004 opti_type = OPTI_TYPE_ZERO_BYTE
7005 | OPTI_TYPE_NOT_ITERATED;
7006 dgst_pos0 = 0;
7007 dgst_pos1 = 3;
7008 dgst_pos2 = 2;
7009 dgst_pos3 = 1;
7010 break;
7011
7012 case 100: hash_type = HASH_TYPE_SHA1;
7013 salt_type = SALT_TYPE_NONE;
7014 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7015 opts_type = OPTS_TYPE_PT_GENERATE_BE
7016 | OPTS_TYPE_PT_ADD80
7017 | OPTS_TYPE_PT_ADDBITS15;
7018 kern_type = KERN_TYPE_SHA1;
7019 dgst_size = DGST_SIZE_4_5;
7020 parse_func = sha1_parse_hash;
7021 sort_by_digest = sort_by_digest_4_5;
7022 opti_type = OPTI_TYPE_ZERO_BYTE
7023 | OPTI_TYPE_PRECOMPUTE_INIT
7024 | OPTI_TYPE_PRECOMPUTE_MERKLE
7025 | OPTI_TYPE_EARLY_SKIP
7026 | OPTI_TYPE_NOT_ITERATED
7027 | OPTI_TYPE_NOT_SALTED
7028 | OPTI_TYPE_RAW_HASH;
7029 dgst_pos0 = 3;
7030 dgst_pos1 = 4;
7031 dgst_pos2 = 2;
7032 dgst_pos3 = 1;
7033 break;
7034
7035 case 101: hash_type = HASH_TYPE_SHA1;
7036 salt_type = SALT_TYPE_NONE;
7037 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7038 opts_type = OPTS_TYPE_PT_GENERATE_BE
7039 | OPTS_TYPE_PT_ADD80
7040 | OPTS_TYPE_PT_ADDBITS15;
7041 kern_type = KERN_TYPE_SHA1;
7042 dgst_size = DGST_SIZE_4_5;
7043 parse_func = sha1b64_parse_hash;
7044 sort_by_digest = sort_by_digest_4_5;
7045 opti_type = OPTI_TYPE_ZERO_BYTE
7046 | OPTI_TYPE_PRECOMPUTE_INIT
7047 | OPTI_TYPE_PRECOMPUTE_MERKLE
7048 | OPTI_TYPE_EARLY_SKIP
7049 | OPTI_TYPE_NOT_ITERATED
7050 | OPTI_TYPE_NOT_SALTED
7051 | OPTI_TYPE_RAW_HASH;
7052 dgst_pos0 = 3;
7053 dgst_pos1 = 4;
7054 dgst_pos2 = 2;
7055 dgst_pos3 = 1;
7056 break;
7057
7058 case 110: hash_type = HASH_TYPE_SHA1;
7059 salt_type = SALT_TYPE_INTERN;
7060 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7061 opts_type = OPTS_TYPE_PT_GENERATE_BE
7062 | OPTS_TYPE_ST_ADD80
7063 | OPTS_TYPE_ST_ADDBITS15;
7064 kern_type = KERN_TYPE_SHA1_PWSLT;
7065 dgst_size = DGST_SIZE_4_5;
7066 parse_func = sha1s_parse_hash;
7067 sort_by_digest = sort_by_digest_4_5;
7068 opti_type = OPTI_TYPE_ZERO_BYTE
7069 | OPTI_TYPE_PRECOMPUTE_INIT
7070 | OPTI_TYPE_PRECOMPUTE_MERKLE
7071 | OPTI_TYPE_EARLY_SKIP
7072 | OPTI_TYPE_NOT_ITERATED
7073 | OPTI_TYPE_APPENDED_SALT
7074 | OPTI_TYPE_RAW_HASH;
7075 dgst_pos0 = 3;
7076 dgst_pos1 = 4;
7077 dgst_pos2 = 2;
7078 dgst_pos3 = 1;
7079 break;
7080
7081 case 111: hash_type = HASH_TYPE_SHA1;
7082 salt_type = SALT_TYPE_EMBEDDED;
7083 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7084 opts_type = OPTS_TYPE_PT_GENERATE_BE
7085 | OPTS_TYPE_ST_ADD80
7086 | OPTS_TYPE_ST_ADDBITS15;
7087 kern_type = KERN_TYPE_SHA1_PWSLT;
7088 dgst_size = DGST_SIZE_4_5;
7089 parse_func = sha1b64s_parse_hash;
7090 sort_by_digest = sort_by_digest_4_5;
7091 opti_type = OPTI_TYPE_ZERO_BYTE
7092 | OPTI_TYPE_PRECOMPUTE_INIT
7093 | OPTI_TYPE_PRECOMPUTE_MERKLE
7094 | OPTI_TYPE_EARLY_SKIP
7095 | OPTI_TYPE_NOT_ITERATED
7096 | OPTI_TYPE_APPENDED_SALT
7097 | OPTI_TYPE_RAW_HASH;
7098 dgst_pos0 = 3;
7099 dgst_pos1 = 4;
7100 dgst_pos2 = 2;
7101 dgst_pos3 = 1;
7102 break;
7103
7104 case 112: hash_type = HASH_TYPE_SHA1;
7105 salt_type = SALT_TYPE_INTERN;
7106 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7107 opts_type = OPTS_TYPE_PT_GENERATE_BE
7108 | OPTS_TYPE_ST_ADD80
7109 | OPTS_TYPE_ST_ADDBITS15
7110 | OPTS_TYPE_ST_HEX;
7111 kern_type = KERN_TYPE_SHA1_PWSLT;
7112 dgst_size = DGST_SIZE_4_5;
7113 parse_func = oracles_parse_hash;
7114 sort_by_digest = sort_by_digest_4_5;
7115 opti_type = OPTI_TYPE_ZERO_BYTE
7116 | OPTI_TYPE_PRECOMPUTE_INIT
7117 | OPTI_TYPE_PRECOMPUTE_MERKLE
7118 | OPTI_TYPE_EARLY_SKIP
7119 | OPTI_TYPE_NOT_ITERATED
7120 | OPTI_TYPE_APPENDED_SALT
7121 | OPTI_TYPE_RAW_HASH;
7122 dgst_pos0 = 3;
7123 dgst_pos1 = 4;
7124 dgst_pos2 = 2;
7125 dgst_pos3 = 1;
7126 break;
7127
7128 case 120: hash_type = HASH_TYPE_SHA1;
7129 salt_type = SALT_TYPE_INTERN;
7130 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7131 opts_type = OPTS_TYPE_PT_GENERATE_BE
7132 | OPTS_TYPE_PT_ADD80
7133 | OPTS_TYPE_PT_ADDBITS15;
7134 kern_type = KERN_TYPE_SHA1_SLTPW;
7135 dgst_size = DGST_SIZE_4_5;
7136 parse_func = sha1s_parse_hash;
7137 sort_by_digest = sort_by_digest_4_5;
7138 opti_type = OPTI_TYPE_ZERO_BYTE
7139 | OPTI_TYPE_PRECOMPUTE_INIT
7140 | OPTI_TYPE_PRECOMPUTE_MERKLE
7141 | OPTI_TYPE_EARLY_SKIP
7142 | OPTI_TYPE_NOT_ITERATED
7143 | OPTI_TYPE_PREPENDED_SALT
7144 | OPTI_TYPE_RAW_HASH;
7145 dgst_pos0 = 3;
7146 dgst_pos1 = 4;
7147 dgst_pos2 = 2;
7148 dgst_pos3 = 1;
7149 break;
7150
7151 case 121: hash_type = HASH_TYPE_SHA1;
7152 salt_type = SALT_TYPE_INTERN;
7153 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7154 opts_type = OPTS_TYPE_PT_GENERATE_BE
7155 | OPTS_TYPE_PT_ADD80
7156 | OPTS_TYPE_PT_ADDBITS15
7157 | OPTS_TYPE_ST_LOWER;
7158 kern_type = KERN_TYPE_SHA1_SLTPW;
7159 dgst_size = DGST_SIZE_4_5;
7160 parse_func = smf_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_PREPENDED_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 122: 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_PT_ADD80
7180 | OPTS_TYPE_PT_ADDBITS15
7181 | OPTS_TYPE_ST_HEX;
7182 kern_type = KERN_TYPE_SHA1_SLTPW;
7183 dgst_size = DGST_SIZE_4_5;
7184 parse_func = osx1_parse_hash;
7185 sort_by_digest = sort_by_digest_4_5;
7186 opti_type = OPTI_TYPE_ZERO_BYTE
7187 | OPTI_TYPE_PRECOMPUTE_INIT
7188 | OPTI_TYPE_PRECOMPUTE_MERKLE
7189 | OPTI_TYPE_EARLY_SKIP
7190 | OPTI_TYPE_NOT_ITERATED
7191 | OPTI_TYPE_PREPENDED_SALT
7192 | OPTI_TYPE_RAW_HASH;
7193 dgst_pos0 = 3;
7194 dgst_pos1 = 4;
7195 dgst_pos2 = 2;
7196 dgst_pos3 = 1;
7197 break;
7198
7199 case 124: hash_type = HASH_TYPE_SHA1;
7200 salt_type = SALT_TYPE_EMBEDDED;
7201 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7202 opts_type = OPTS_TYPE_PT_GENERATE_BE
7203 | OPTS_TYPE_PT_ADD80
7204 | OPTS_TYPE_PT_ADDBITS15;
7205 kern_type = KERN_TYPE_SHA1_SLTPW;
7206 dgst_size = DGST_SIZE_4_5;
7207 parse_func = djangosha1_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_PREPENDED_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 125: hash_type = HASH_TYPE_SHA1;
7223 salt_type = SALT_TYPE_EMBEDDED;
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 | OPTS_TYPE_ST_HEX;
7229 kern_type = KERN_TYPE_SHA1_SLTPW;
7230 dgst_size = DGST_SIZE_4_5;
7231 parse_func = arubaos_parse_hash;
7232 sort_by_digest = sort_by_digest_4_5;
7233 opti_type = OPTI_TYPE_ZERO_BYTE
7234 | OPTI_TYPE_PRECOMPUTE_INIT
7235 | OPTI_TYPE_PRECOMPUTE_MERKLE
7236 | OPTI_TYPE_EARLY_SKIP
7237 | OPTI_TYPE_NOT_ITERATED
7238 | OPTI_TYPE_PREPENDED_SALT
7239 | OPTI_TYPE_RAW_HASH;
7240 dgst_pos0 = 3;
7241 dgst_pos1 = 4;
7242 dgst_pos2 = 2;
7243 dgst_pos3 = 1;
7244 break;
7245
7246 case 130: hash_type = HASH_TYPE_SHA1;
7247 salt_type = SALT_TYPE_INTERN;
7248 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7249 opts_type = OPTS_TYPE_PT_GENERATE_BE
7250 | OPTS_TYPE_PT_UNICODE
7251 | OPTS_TYPE_ST_ADD80
7252 | OPTS_TYPE_ST_ADDBITS15;
7253 kern_type = KERN_TYPE_SHA1_PWUSLT;
7254 dgst_size = DGST_SIZE_4_5;
7255 parse_func = sha1s_parse_hash;
7256 sort_by_digest = sort_by_digest_4_5;
7257 opti_type = OPTI_TYPE_ZERO_BYTE
7258 | OPTI_TYPE_PRECOMPUTE_INIT
7259 | OPTI_TYPE_PRECOMPUTE_MERKLE
7260 | OPTI_TYPE_EARLY_SKIP
7261 | OPTI_TYPE_NOT_ITERATED
7262 | OPTI_TYPE_APPENDED_SALT
7263 | OPTI_TYPE_RAW_HASH;
7264 dgst_pos0 = 3;
7265 dgst_pos1 = 4;
7266 dgst_pos2 = 2;
7267 dgst_pos3 = 1;
7268 break;
7269
7270 case 131: hash_type = HASH_TYPE_SHA1;
7271 salt_type = SALT_TYPE_EMBEDDED;
7272 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7273 opts_type = OPTS_TYPE_PT_GENERATE_BE
7274 | OPTS_TYPE_PT_UNICODE
7275 | OPTS_TYPE_PT_UPPER
7276 | OPTS_TYPE_ST_ADD80
7277 | OPTS_TYPE_ST_ADDBITS15
7278 | OPTS_TYPE_ST_HEX;
7279 kern_type = KERN_TYPE_SHA1_PWUSLT;
7280 dgst_size = DGST_SIZE_4_5;
7281 parse_func = mssql2000_parse_hash;
7282 sort_by_digest = sort_by_digest_4_5;
7283 opti_type = OPTI_TYPE_ZERO_BYTE
7284 | OPTI_TYPE_PRECOMPUTE_INIT
7285 | OPTI_TYPE_PRECOMPUTE_MERKLE
7286 | OPTI_TYPE_EARLY_SKIP
7287 | OPTI_TYPE_NOT_ITERATED
7288 | OPTI_TYPE_APPENDED_SALT
7289 | OPTI_TYPE_RAW_HASH;
7290 dgst_pos0 = 3;
7291 dgst_pos1 = 4;
7292 dgst_pos2 = 2;
7293 dgst_pos3 = 1;
7294 break;
7295
7296 case 132: hash_type = HASH_TYPE_SHA1;
7297 salt_type = SALT_TYPE_EMBEDDED;
7298 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7299 opts_type = OPTS_TYPE_PT_GENERATE_BE
7300 | OPTS_TYPE_PT_UNICODE
7301 | OPTS_TYPE_ST_ADD80
7302 | OPTS_TYPE_ST_ADDBITS15
7303 | OPTS_TYPE_ST_HEX;
7304 kern_type = KERN_TYPE_SHA1_PWUSLT;
7305 dgst_size = DGST_SIZE_4_5;
7306 parse_func = mssql2005_parse_hash;
7307 sort_by_digest = sort_by_digest_4_5;
7308 opti_type = OPTI_TYPE_ZERO_BYTE
7309 | OPTI_TYPE_PRECOMPUTE_INIT
7310 | OPTI_TYPE_PRECOMPUTE_MERKLE
7311 | OPTI_TYPE_EARLY_SKIP
7312 | OPTI_TYPE_NOT_ITERATED
7313 | OPTI_TYPE_APPENDED_SALT
7314 | OPTI_TYPE_RAW_HASH;
7315 dgst_pos0 = 3;
7316 dgst_pos1 = 4;
7317 dgst_pos2 = 2;
7318 dgst_pos3 = 1;
7319 break;
7320
7321 case 133: hash_type = HASH_TYPE_SHA1;
7322 salt_type = SALT_TYPE_EMBEDDED;
7323 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7324 opts_type = OPTS_TYPE_PT_GENERATE_BE
7325 | OPTS_TYPE_PT_UNICODE
7326 | OPTS_TYPE_ST_ADD80
7327 | OPTS_TYPE_ST_ADDBITS15;
7328 kern_type = KERN_TYPE_SHA1_PWUSLT;
7329 dgst_size = DGST_SIZE_4_5;
7330 parse_func = peoplesoft_parse_hash;
7331 sort_by_digest = sort_by_digest_4_5;
7332 opti_type = OPTI_TYPE_ZERO_BYTE
7333 | OPTI_TYPE_PRECOMPUTE_INIT
7334 | OPTI_TYPE_PRECOMPUTE_MERKLE
7335 | OPTI_TYPE_EARLY_SKIP
7336 | OPTI_TYPE_NOT_ITERATED
7337 | OPTI_TYPE_APPENDED_SALT
7338 | OPTI_TYPE_RAW_HASH;
7339 dgst_pos0 = 3;
7340 dgst_pos1 = 4;
7341 dgst_pos2 = 2;
7342 dgst_pos3 = 1;
7343 break;
7344
7345 case 140: hash_type = HASH_TYPE_SHA1;
7346 salt_type = SALT_TYPE_INTERN;
7347 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7348 opts_type = OPTS_TYPE_PT_GENERATE_BE
7349 | OPTS_TYPE_PT_ADD80
7350 | OPTS_TYPE_PT_ADDBITS15
7351 | OPTS_TYPE_PT_UNICODE;
7352 kern_type = KERN_TYPE_SHA1_SLTPWU;
7353 dgst_size = DGST_SIZE_4_5;
7354 parse_func = sha1s_parse_hash;
7355 sort_by_digest = sort_by_digest_4_5;
7356 opti_type = OPTI_TYPE_ZERO_BYTE
7357 | OPTI_TYPE_PRECOMPUTE_INIT
7358 | OPTI_TYPE_PRECOMPUTE_MERKLE
7359 | OPTI_TYPE_EARLY_SKIP
7360 | OPTI_TYPE_NOT_ITERATED
7361 | OPTI_TYPE_PREPENDED_SALT
7362 | OPTI_TYPE_RAW_HASH;
7363 dgst_pos0 = 3;
7364 dgst_pos1 = 4;
7365 dgst_pos2 = 2;
7366 dgst_pos3 = 1;
7367 break;
7368
7369 case 141: hash_type = HASH_TYPE_SHA1;
7370 salt_type = SALT_TYPE_EMBEDDED;
7371 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7372 opts_type = OPTS_TYPE_PT_GENERATE_BE
7373 | OPTS_TYPE_PT_ADD80
7374 | OPTS_TYPE_PT_ADDBITS15
7375 | OPTS_TYPE_PT_UNICODE
7376 | OPTS_TYPE_ST_BASE64;
7377 kern_type = KERN_TYPE_SHA1_SLTPWU;
7378 dgst_size = DGST_SIZE_4_5;
7379 parse_func = episerver_parse_hash;
7380 sort_by_digest = sort_by_digest_4_5;
7381 opti_type = OPTI_TYPE_ZERO_BYTE
7382 | OPTI_TYPE_PRECOMPUTE_INIT
7383 | OPTI_TYPE_PRECOMPUTE_MERKLE
7384 | OPTI_TYPE_EARLY_SKIP
7385 | OPTI_TYPE_NOT_ITERATED
7386 | OPTI_TYPE_PREPENDED_SALT
7387 | OPTI_TYPE_RAW_HASH;
7388 dgst_pos0 = 3;
7389 dgst_pos1 = 4;
7390 dgst_pos2 = 2;
7391 dgst_pos3 = 1;
7392 break;
7393
7394 case 150: hash_type = HASH_TYPE_SHA1;
7395 salt_type = SALT_TYPE_INTERN;
7396 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7397 opts_type = OPTS_TYPE_PT_GENERATE_BE
7398 | OPTS_TYPE_ST_ADD80
7399 | OPTS_TYPE_ST_ADDBITS15;
7400 kern_type = KERN_TYPE_HMACSHA1_PW;
7401 dgst_size = DGST_SIZE_4_5;
7402 parse_func = hmacsha1_parse_hash;
7403 sort_by_digest = sort_by_digest_4_5;
7404 opti_type = OPTI_TYPE_ZERO_BYTE
7405 | OPTI_TYPE_NOT_ITERATED;
7406 dgst_pos0 = 3;
7407 dgst_pos1 = 4;
7408 dgst_pos2 = 2;
7409 dgst_pos3 = 1;
7410 break;
7411
7412 case 160: hash_type = HASH_TYPE_SHA1;
7413 salt_type = SALT_TYPE_INTERN;
7414 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7415 opts_type = OPTS_TYPE_PT_GENERATE_BE
7416 | OPTS_TYPE_PT_ADD80
7417 | OPTS_TYPE_PT_ADDBITS15;
7418 kern_type = KERN_TYPE_HMACSHA1_SLT;
7419 dgst_size = DGST_SIZE_4_5;
7420 parse_func = hmacsha1_parse_hash;
7421 sort_by_digest = sort_by_digest_4_5;
7422 opti_type = OPTI_TYPE_ZERO_BYTE
7423 | OPTI_TYPE_NOT_ITERATED;
7424 dgst_pos0 = 3;
7425 dgst_pos1 = 4;
7426 dgst_pos2 = 2;
7427 dgst_pos3 = 1;
7428 break;
7429
7430 case 190: hash_type = HASH_TYPE_SHA1;
7431 salt_type = SALT_TYPE_NONE;
7432 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7433 opts_type = OPTS_TYPE_PT_GENERATE_BE
7434 | OPTS_TYPE_PT_ADD80
7435 | OPTS_TYPE_PT_ADDBITS15;
7436 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7437 dgst_size = DGST_SIZE_4_5;
7438 parse_func = sha1linkedin_parse_hash;
7439 sort_by_digest = sort_by_digest_4_5;
7440 opti_type = OPTI_TYPE_ZERO_BYTE
7441 | OPTI_TYPE_PRECOMPUTE_INIT
7442 | OPTI_TYPE_EARLY_SKIP
7443 | OPTI_TYPE_NOT_ITERATED
7444 | OPTI_TYPE_NOT_SALTED;
7445 dgst_pos0 = 0;
7446 dgst_pos1 = 4;
7447 dgst_pos2 = 3;
7448 dgst_pos3 = 2;
7449 break;
7450
7451 case 200: hash_type = HASH_TYPE_MYSQL;
7452 salt_type = SALT_TYPE_NONE;
7453 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7454 opts_type = 0;
7455 kern_type = KERN_TYPE_MYSQL;
7456 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7457 parse_func = mysql323_parse_hash;
7458 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7459 opti_type = OPTI_TYPE_ZERO_BYTE;
7460 dgst_pos0 = 0;
7461 dgst_pos1 = 1;
7462 dgst_pos2 = 2;
7463 dgst_pos3 = 3;
7464 break;
7465
7466 case 300: hash_type = HASH_TYPE_SHA1;
7467 salt_type = SALT_TYPE_NONE;
7468 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7469 opts_type = OPTS_TYPE_PT_GENERATE_BE
7470 | OPTS_TYPE_PT_ADD80
7471 | OPTS_TYPE_PT_ADDBITS15;
7472 kern_type = KERN_TYPE_MYSQL41;
7473 dgst_size = DGST_SIZE_4_5;
7474 parse_func = sha1_parse_hash;
7475 sort_by_digest = sort_by_digest_4_5;
7476 opti_type = OPTI_TYPE_ZERO_BYTE
7477 | OPTI_TYPE_PRECOMPUTE_INIT
7478 | OPTI_TYPE_PRECOMPUTE_MERKLE
7479 | OPTI_TYPE_EARLY_SKIP
7480 | OPTI_TYPE_NOT_ITERATED
7481 | OPTI_TYPE_NOT_SALTED;
7482 dgst_pos0 = 3;
7483 dgst_pos1 = 4;
7484 dgst_pos2 = 2;
7485 dgst_pos3 = 1;
7486 break;
7487
7488 case 400: hash_type = HASH_TYPE_MD5;
7489 salt_type = SALT_TYPE_EMBEDDED;
7490 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7491 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7492 kern_type = KERN_TYPE_PHPASS;
7493 dgst_size = DGST_SIZE_4_4;
7494 parse_func = phpass_parse_hash;
7495 sort_by_digest = sort_by_digest_4_4;
7496 opti_type = OPTI_TYPE_ZERO_BYTE
7497 | OPTI_TYPE_SLOW_HASH_SIMD;
7498 dgst_pos0 = 0;
7499 dgst_pos1 = 1;
7500 dgst_pos2 = 2;
7501 dgst_pos3 = 3;
7502 break;
7503
7504 case 500: hash_type = HASH_TYPE_MD5;
7505 salt_type = SALT_TYPE_EMBEDDED;
7506 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7507 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7508 kern_type = KERN_TYPE_MD5CRYPT;
7509 dgst_size = DGST_SIZE_4_4;
7510 parse_func = md5crypt_parse_hash;
7511 sort_by_digest = sort_by_digest_4_4;
7512 opti_type = OPTI_TYPE_ZERO_BYTE;
7513 dgst_pos0 = 0;
7514 dgst_pos1 = 1;
7515 dgst_pos2 = 2;
7516 dgst_pos3 = 3;
7517 break;
7518
7519 case 501: hash_type = HASH_TYPE_MD5;
7520 salt_type = SALT_TYPE_EMBEDDED;
7521 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7522 opts_type = OPTS_TYPE_PT_GENERATE_LE
7523 | OPTS_TYPE_HASH_COPY;
7524 kern_type = KERN_TYPE_MD5CRYPT;
7525 dgst_size = DGST_SIZE_4_4;
7526 parse_func = juniper_parse_hash;
7527 sort_by_digest = sort_by_digest_4_4;
7528 opti_type = OPTI_TYPE_ZERO_BYTE;
7529 dgst_pos0 = 0;
7530 dgst_pos1 = 1;
7531 dgst_pos2 = 2;
7532 dgst_pos3 = 3;
7533 break;
7534
7535 case 900: hash_type = HASH_TYPE_MD4;
7536 salt_type = SALT_TYPE_NONE;
7537 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7538 opts_type = OPTS_TYPE_PT_GENERATE_LE
7539 | OPTS_TYPE_PT_ADD80
7540 | OPTS_TYPE_PT_ADDBITS14;
7541 kern_type = KERN_TYPE_MD4;
7542 dgst_size = DGST_SIZE_4_4;
7543 parse_func = md4_parse_hash;
7544 sort_by_digest = sort_by_digest_4_4;
7545 opti_type = OPTI_TYPE_ZERO_BYTE
7546 | OPTI_TYPE_PRECOMPUTE_INIT
7547 | OPTI_TYPE_PRECOMPUTE_MERKLE
7548 | OPTI_TYPE_MEET_IN_MIDDLE
7549 | OPTI_TYPE_EARLY_SKIP
7550 | OPTI_TYPE_NOT_ITERATED
7551 | OPTI_TYPE_NOT_SALTED
7552 | OPTI_TYPE_RAW_HASH;
7553 dgst_pos0 = 0;
7554 dgst_pos1 = 3;
7555 dgst_pos2 = 2;
7556 dgst_pos3 = 1;
7557 break;
7558
7559 case 1000: hash_type = HASH_TYPE_MD4;
7560 salt_type = SALT_TYPE_NONE;
7561 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7562 opts_type = OPTS_TYPE_PT_GENERATE_LE
7563 | OPTS_TYPE_PT_ADD80
7564 | OPTS_TYPE_PT_ADDBITS14
7565 | OPTS_TYPE_PT_UNICODE;
7566 kern_type = KERN_TYPE_MD4_PWU;
7567 dgst_size = DGST_SIZE_4_4;
7568 parse_func = md4_parse_hash;
7569 sort_by_digest = sort_by_digest_4_4;
7570 opti_type = OPTI_TYPE_ZERO_BYTE
7571 | OPTI_TYPE_PRECOMPUTE_INIT
7572 | OPTI_TYPE_PRECOMPUTE_MERKLE
7573 | OPTI_TYPE_MEET_IN_MIDDLE
7574 | OPTI_TYPE_EARLY_SKIP
7575 | OPTI_TYPE_NOT_ITERATED
7576 | OPTI_TYPE_NOT_SALTED
7577 | OPTI_TYPE_RAW_HASH;
7578 dgst_pos0 = 0;
7579 dgst_pos1 = 3;
7580 dgst_pos2 = 2;
7581 dgst_pos3 = 1;
7582 break;
7583
7584 case 1100: hash_type = HASH_TYPE_MD4;
7585 salt_type = SALT_TYPE_INTERN;
7586 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7587 opts_type = OPTS_TYPE_PT_GENERATE_LE
7588 | OPTS_TYPE_PT_ADD80
7589 | OPTS_TYPE_PT_ADDBITS14
7590 | OPTS_TYPE_PT_UNICODE
7591 | OPTS_TYPE_ST_ADD80
7592 | OPTS_TYPE_ST_UNICODE
7593 | OPTS_TYPE_ST_LOWER;
7594 kern_type = KERN_TYPE_MD44_PWUSLT;
7595 dgst_size = DGST_SIZE_4_4;
7596 parse_func = dcc_parse_hash;
7597 sort_by_digest = sort_by_digest_4_4;
7598 opti_type = OPTI_TYPE_ZERO_BYTE
7599 | OPTI_TYPE_PRECOMPUTE_INIT
7600 | OPTI_TYPE_PRECOMPUTE_MERKLE
7601 | OPTI_TYPE_EARLY_SKIP
7602 | OPTI_TYPE_NOT_ITERATED;
7603 dgst_pos0 = 0;
7604 dgst_pos1 = 3;
7605 dgst_pos2 = 2;
7606 dgst_pos3 = 1;
7607 break;
7608
7609 case 1400: hash_type = HASH_TYPE_SHA256;
7610 salt_type = SALT_TYPE_NONE;
7611 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7612 opts_type = OPTS_TYPE_PT_GENERATE_BE
7613 | OPTS_TYPE_PT_ADD80
7614 | OPTS_TYPE_PT_ADDBITS15;
7615 kern_type = KERN_TYPE_SHA256;
7616 dgst_size = DGST_SIZE_4_8;
7617 parse_func = sha256_parse_hash;
7618 sort_by_digest = sort_by_digest_4_8;
7619 opti_type = OPTI_TYPE_ZERO_BYTE
7620 | OPTI_TYPE_PRECOMPUTE_INIT
7621 | OPTI_TYPE_PRECOMPUTE_MERKLE
7622 | OPTI_TYPE_EARLY_SKIP
7623 | OPTI_TYPE_NOT_ITERATED
7624 | OPTI_TYPE_NOT_SALTED
7625 | OPTI_TYPE_RAW_HASH;
7626 dgst_pos0 = 3;
7627 dgst_pos1 = 7;
7628 dgst_pos2 = 2;
7629 dgst_pos3 = 6;
7630 break;
7631
7632 case 1410: hash_type = HASH_TYPE_SHA256;
7633 salt_type = SALT_TYPE_INTERN;
7634 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7635 opts_type = OPTS_TYPE_PT_GENERATE_BE
7636 | OPTS_TYPE_ST_ADD80
7637 | OPTS_TYPE_ST_ADDBITS15;
7638 kern_type = KERN_TYPE_SHA256_PWSLT;
7639 dgst_size = DGST_SIZE_4_8;
7640 parse_func = sha256s_parse_hash;
7641 sort_by_digest = sort_by_digest_4_8;
7642 opti_type = OPTI_TYPE_ZERO_BYTE
7643 | OPTI_TYPE_PRECOMPUTE_INIT
7644 | OPTI_TYPE_PRECOMPUTE_MERKLE
7645 | OPTI_TYPE_EARLY_SKIP
7646 | OPTI_TYPE_NOT_ITERATED
7647 | OPTI_TYPE_APPENDED_SALT
7648 | OPTI_TYPE_RAW_HASH;
7649 dgst_pos0 = 3;
7650 dgst_pos1 = 7;
7651 dgst_pos2 = 2;
7652 dgst_pos3 = 6;
7653 break;
7654
7655 case 1420: hash_type = HASH_TYPE_SHA256;
7656 salt_type = SALT_TYPE_INTERN;
7657 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7658 opts_type = OPTS_TYPE_PT_GENERATE_BE
7659 | OPTS_TYPE_PT_ADD80
7660 | OPTS_TYPE_PT_ADDBITS15;
7661 kern_type = KERN_TYPE_SHA256_SLTPW;
7662 dgst_size = DGST_SIZE_4_8;
7663 parse_func = sha256s_parse_hash;
7664 sort_by_digest = sort_by_digest_4_8;
7665 opti_type = OPTI_TYPE_ZERO_BYTE
7666 | OPTI_TYPE_PRECOMPUTE_INIT
7667 | OPTI_TYPE_PRECOMPUTE_MERKLE
7668 | OPTI_TYPE_EARLY_SKIP
7669 | OPTI_TYPE_NOT_ITERATED
7670 | OPTI_TYPE_PREPENDED_SALT
7671 | OPTI_TYPE_RAW_HASH;
7672 dgst_pos0 = 3;
7673 dgst_pos1 = 7;
7674 dgst_pos2 = 2;
7675 dgst_pos3 = 6;
7676 break;
7677
7678 case 1421: hash_type = HASH_TYPE_SHA256;
7679 salt_type = SALT_TYPE_EMBEDDED;
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_SLTPW;
7685 dgst_size = DGST_SIZE_4_8;
7686 parse_func = hmailserver_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_PREPENDED_SALT
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 1430: 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_PT_UNICODE
7706 | OPTS_TYPE_ST_ADD80
7707 | OPTS_TYPE_ST_ADDBITS15;
7708 kern_type = KERN_TYPE_SHA256_PWUSLT;
7709 dgst_size = DGST_SIZE_4_8;
7710 parse_func = sha256s_parse_hash;
7711 sort_by_digest = sort_by_digest_4_8;
7712 opti_type = OPTI_TYPE_ZERO_BYTE
7713 | OPTI_TYPE_PRECOMPUTE_INIT
7714 | OPTI_TYPE_PRECOMPUTE_MERKLE
7715 | OPTI_TYPE_EARLY_SKIP
7716 | OPTI_TYPE_NOT_ITERATED
7717 | OPTI_TYPE_APPENDED_SALT
7718 | OPTI_TYPE_RAW_HASH;
7719 dgst_pos0 = 3;
7720 dgst_pos1 = 7;
7721 dgst_pos2 = 2;
7722 dgst_pos3 = 6;
7723 break;
7724
7725 case 1440: hash_type = HASH_TYPE_SHA256;
7726 salt_type = SALT_TYPE_INTERN;
7727 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7728 opts_type = OPTS_TYPE_PT_GENERATE_BE
7729 | OPTS_TYPE_PT_ADD80
7730 | OPTS_TYPE_PT_ADDBITS15
7731 | OPTS_TYPE_PT_UNICODE;
7732 kern_type = KERN_TYPE_SHA256_SLTPWU;
7733 dgst_size = DGST_SIZE_4_8;
7734 parse_func = sha256s_parse_hash;
7735 sort_by_digest = sort_by_digest_4_8;
7736 opti_type = OPTI_TYPE_ZERO_BYTE
7737 | OPTI_TYPE_PRECOMPUTE_INIT
7738 | OPTI_TYPE_PRECOMPUTE_MERKLE
7739 | OPTI_TYPE_EARLY_SKIP
7740 | OPTI_TYPE_NOT_ITERATED
7741 | OPTI_TYPE_PREPENDED_SALT
7742 | OPTI_TYPE_RAW_HASH;
7743 dgst_pos0 = 3;
7744 dgst_pos1 = 7;
7745 dgst_pos2 = 2;
7746 dgst_pos3 = 6;
7747 break;
7748
7749 case 1441: hash_type = HASH_TYPE_SHA256;
7750 salt_type = SALT_TYPE_EMBEDDED;
7751 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7752 opts_type = OPTS_TYPE_PT_GENERATE_BE
7753 | OPTS_TYPE_PT_ADD80
7754 | OPTS_TYPE_PT_ADDBITS15
7755 | OPTS_TYPE_PT_UNICODE
7756 | OPTS_TYPE_ST_BASE64;
7757 kern_type = KERN_TYPE_SHA256_SLTPWU;
7758 dgst_size = DGST_SIZE_4_8;
7759 parse_func = episerver4_parse_hash;
7760 sort_by_digest = sort_by_digest_4_8;
7761 opti_type = OPTI_TYPE_ZERO_BYTE
7762 | OPTI_TYPE_PRECOMPUTE_INIT
7763 | OPTI_TYPE_PRECOMPUTE_MERKLE
7764 | OPTI_TYPE_EARLY_SKIP
7765 | OPTI_TYPE_NOT_ITERATED
7766 | OPTI_TYPE_PREPENDED_SALT
7767 | OPTI_TYPE_RAW_HASH;
7768 dgst_pos0 = 3;
7769 dgst_pos1 = 7;
7770 dgst_pos2 = 2;
7771 dgst_pos3 = 6;
7772 break;
7773
7774 case 1450: hash_type = HASH_TYPE_SHA256;
7775 salt_type = SALT_TYPE_INTERN;
7776 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7777 opts_type = OPTS_TYPE_PT_GENERATE_BE
7778 | OPTS_TYPE_ST_ADD80;
7779 kern_type = KERN_TYPE_HMACSHA256_PW;
7780 dgst_size = DGST_SIZE_4_8;
7781 parse_func = hmacsha256_parse_hash;
7782 sort_by_digest = sort_by_digest_4_8;
7783 opti_type = OPTI_TYPE_ZERO_BYTE
7784 | OPTI_TYPE_NOT_ITERATED;
7785 dgst_pos0 = 3;
7786 dgst_pos1 = 7;
7787 dgst_pos2 = 2;
7788 dgst_pos3 = 6;
7789 break;
7790
7791 case 1460: hash_type = HASH_TYPE_SHA256;
7792 salt_type = SALT_TYPE_INTERN;
7793 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7794 opts_type = OPTS_TYPE_PT_GENERATE_BE
7795 | OPTS_TYPE_PT_ADD80
7796 | OPTS_TYPE_PT_ADDBITS15;
7797 kern_type = KERN_TYPE_HMACSHA256_SLT;
7798 dgst_size = DGST_SIZE_4_8;
7799 parse_func = hmacsha256_parse_hash;
7800 sort_by_digest = sort_by_digest_4_8;
7801 opti_type = OPTI_TYPE_ZERO_BYTE
7802 | OPTI_TYPE_NOT_ITERATED;
7803 dgst_pos0 = 3;
7804 dgst_pos1 = 7;
7805 dgst_pos2 = 2;
7806 dgst_pos3 = 6;
7807 break;
7808
7809 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7810 salt_type = SALT_TYPE_EMBEDDED;
7811 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7812 opts_type = OPTS_TYPE_PT_GENERATE_LE
7813 | OPTS_TYPE_PT_BITSLICE;
7814 kern_type = KERN_TYPE_DESCRYPT;
7815 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7816 parse_func = descrypt_parse_hash;
7817 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7818 opti_type = OPTI_TYPE_ZERO_BYTE
7819 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7820 dgst_pos0 = 0;
7821 dgst_pos1 = 1;
7822 dgst_pos2 = 2;
7823 dgst_pos3 = 3;
7824 break;
7825
7826 case 1600: hash_type = HASH_TYPE_MD5;
7827 salt_type = SALT_TYPE_EMBEDDED;
7828 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7829 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7830 kern_type = KERN_TYPE_APR1CRYPT;
7831 dgst_size = DGST_SIZE_4_4;
7832 parse_func = md5apr1_parse_hash;
7833 sort_by_digest = sort_by_digest_4_4;
7834 opti_type = OPTI_TYPE_ZERO_BYTE;
7835 dgst_pos0 = 0;
7836 dgst_pos1 = 1;
7837 dgst_pos2 = 2;
7838 dgst_pos3 = 3;
7839 break;
7840
7841 case 1700: hash_type = HASH_TYPE_SHA512;
7842 salt_type = SALT_TYPE_NONE;
7843 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7844 opts_type = OPTS_TYPE_PT_GENERATE_BE
7845 | OPTS_TYPE_PT_ADD80
7846 | OPTS_TYPE_PT_ADDBITS15;
7847 kern_type = KERN_TYPE_SHA512;
7848 dgst_size = DGST_SIZE_8_8;
7849 parse_func = sha512_parse_hash;
7850 sort_by_digest = sort_by_digest_8_8;
7851 opti_type = OPTI_TYPE_ZERO_BYTE
7852 | OPTI_TYPE_PRECOMPUTE_INIT
7853 | OPTI_TYPE_PRECOMPUTE_MERKLE
7854 | OPTI_TYPE_EARLY_SKIP
7855 | OPTI_TYPE_NOT_ITERATED
7856 | OPTI_TYPE_NOT_SALTED
7857 | OPTI_TYPE_USES_BITS_64
7858 | OPTI_TYPE_RAW_HASH;
7859 dgst_pos0 = 14;
7860 dgst_pos1 = 15;
7861 dgst_pos2 = 6;
7862 dgst_pos3 = 7;
7863 break;
7864
7865 case 1710: hash_type = HASH_TYPE_SHA512;
7866 salt_type = SALT_TYPE_INTERN;
7867 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7868 opts_type = OPTS_TYPE_PT_GENERATE_BE
7869 | OPTS_TYPE_ST_ADD80
7870 | OPTS_TYPE_ST_ADDBITS15;
7871 kern_type = KERN_TYPE_SHA512_PWSLT;
7872 dgst_size = DGST_SIZE_8_8;
7873 parse_func = sha512s_parse_hash;
7874 sort_by_digest = sort_by_digest_8_8;
7875 opti_type = OPTI_TYPE_ZERO_BYTE
7876 | OPTI_TYPE_PRECOMPUTE_INIT
7877 | OPTI_TYPE_PRECOMPUTE_MERKLE
7878 | OPTI_TYPE_EARLY_SKIP
7879 | OPTI_TYPE_NOT_ITERATED
7880 | OPTI_TYPE_APPENDED_SALT
7881 | OPTI_TYPE_USES_BITS_64
7882 | OPTI_TYPE_RAW_HASH;
7883 dgst_pos0 = 14;
7884 dgst_pos1 = 15;
7885 dgst_pos2 = 6;
7886 dgst_pos3 = 7;
7887 break;
7888
7889 case 1711: hash_type = HASH_TYPE_SHA512;
7890 salt_type = SALT_TYPE_EMBEDDED;
7891 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7892 opts_type = OPTS_TYPE_PT_GENERATE_BE
7893 | OPTS_TYPE_ST_ADD80
7894 | OPTS_TYPE_ST_ADDBITS15;
7895 kern_type = KERN_TYPE_SHA512_PWSLT;
7896 dgst_size = DGST_SIZE_8_8;
7897 parse_func = sha512b64s_parse_hash;
7898 sort_by_digest = sort_by_digest_8_8;
7899 opti_type = OPTI_TYPE_ZERO_BYTE
7900 | OPTI_TYPE_PRECOMPUTE_INIT
7901 | OPTI_TYPE_PRECOMPUTE_MERKLE
7902 | OPTI_TYPE_EARLY_SKIP
7903 | OPTI_TYPE_NOT_ITERATED
7904 | OPTI_TYPE_APPENDED_SALT
7905 | OPTI_TYPE_USES_BITS_64
7906 | OPTI_TYPE_RAW_HASH;
7907 dgst_pos0 = 14;
7908 dgst_pos1 = 15;
7909 dgst_pos2 = 6;
7910 dgst_pos3 = 7;
7911 break;
7912
7913 case 1720: hash_type = HASH_TYPE_SHA512;
7914 salt_type = SALT_TYPE_INTERN;
7915 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7916 opts_type = OPTS_TYPE_PT_GENERATE_BE
7917 | OPTS_TYPE_PT_ADD80
7918 | OPTS_TYPE_PT_ADDBITS15;
7919 kern_type = KERN_TYPE_SHA512_SLTPW;
7920 dgst_size = DGST_SIZE_8_8;
7921 parse_func = sha512s_parse_hash;
7922 sort_by_digest = sort_by_digest_8_8;
7923 opti_type = OPTI_TYPE_ZERO_BYTE
7924 | OPTI_TYPE_PRECOMPUTE_INIT
7925 | OPTI_TYPE_PRECOMPUTE_MERKLE
7926 | OPTI_TYPE_EARLY_SKIP
7927 | OPTI_TYPE_NOT_ITERATED
7928 | OPTI_TYPE_PREPENDED_SALT
7929 | OPTI_TYPE_USES_BITS_64
7930 | OPTI_TYPE_RAW_HASH;
7931 dgst_pos0 = 14;
7932 dgst_pos1 = 15;
7933 dgst_pos2 = 6;
7934 dgst_pos3 = 7;
7935 break;
7936
7937 case 1722: hash_type = HASH_TYPE_SHA512;
7938 salt_type = SALT_TYPE_EMBEDDED;
7939 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7940 opts_type = OPTS_TYPE_PT_GENERATE_BE
7941 | OPTS_TYPE_PT_ADD80
7942 | OPTS_TYPE_PT_ADDBITS15
7943 | OPTS_TYPE_ST_HEX;
7944 kern_type = KERN_TYPE_SHA512_SLTPW;
7945 dgst_size = DGST_SIZE_8_8;
7946 parse_func = osx512_parse_hash;
7947 sort_by_digest = sort_by_digest_8_8;
7948 opti_type = OPTI_TYPE_ZERO_BYTE
7949 | OPTI_TYPE_PRECOMPUTE_INIT
7950 | OPTI_TYPE_PRECOMPUTE_MERKLE
7951 | OPTI_TYPE_EARLY_SKIP
7952 | OPTI_TYPE_NOT_ITERATED
7953 | OPTI_TYPE_PREPENDED_SALT
7954 | OPTI_TYPE_USES_BITS_64
7955 | OPTI_TYPE_RAW_HASH;
7956 dgst_pos0 = 14;
7957 dgst_pos1 = 15;
7958 dgst_pos2 = 6;
7959 dgst_pos3 = 7;
7960 break;
7961
7962 case 1730: hash_type = HASH_TYPE_SHA512;
7963 salt_type = SALT_TYPE_INTERN;
7964 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7965 opts_type = OPTS_TYPE_PT_GENERATE_BE
7966 | OPTS_TYPE_PT_UNICODE
7967 | OPTS_TYPE_ST_ADD80
7968 | OPTS_TYPE_ST_ADDBITS15;
7969 kern_type = KERN_TYPE_SHA512_PWSLTU;
7970 dgst_size = DGST_SIZE_8_8;
7971 parse_func = sha512s_parse_hash;
7972 sort_by_digest = sort_by_digest_8_8;
7973 opti_type = OPTI_TYPE_ZERO_BYTE
7974 | OPTI_TYPE_PRECOMPUTE_INIT
7975 | OPTI_TYPE_PRECOMPUTE_MERKLE
7976 | OPTI_TYPE_EARLY_SKIP
7977 | OPTI_TYPE_NOT_ITERATED
7978 | OPTI_TYPE_APPENDED_SALT
7979 | OPTI_TYPE_USES_BITS_64
7980 | OPTI_TYPE_RAW_HASH;
7981 dgst_pos0 = 14;
7982 dgst_pos1 = 15;
7983 dgst_pos2 = 6;
7984 dgst_pos3 = 7;
7985 break;
7986
7987 case 1731: hash_type = HASH_TYPE_SHA512;
7988 salt_type = SALT_TYPE_EMBEDDED;
7989 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7990 opts_type = OPTS_TYPE_PT_GENERATE_BE
7991 | OPTS_TYPE_PT_UNICODE
7992 | OPTS_TYPE_ST_ADD80
7993 | OPTS_TYPE_ST_ADDBITS15
7994 | OPTS_TYPE_ST_HEX;
7995 kern_type = KERN_TYPE_SHA512_PWSLTU;
7996 dgst_size = DGST_SIZE_8_8;
7997 parse_func = mssql2012_parse_hash;
7998 sort_by_digest = sort_by_digest_8_8;
7999 opti_type = OPTI_TYPE_ZERO_BYTE
8000 | OPTI_TYPE_PRECOMPUTE_INIT
8001 | OPTI_TYPE_PRECOMPUTE_MERKLE
8002 | OPTI_TYPE_EARLY_SKIP
8003 | OPTI_TYPE_NOT_ITERATED
8004 | OPTI_TYPE_APPENDED_SALT
8005 | OPTI_TYPE_USES_BITS_64
8006 | OPTI_TYPE_RAW_HASH;
8007 dgst_pos0 = 14;
8008 dgst_pos1 = 15;
8009 dgst_pos2 = 6;
8010 dgst_pos3 = 7;
8011 break;
8012
8013 case 1740: hash_type = HASH_TYPE_SHA512;
8014 salt_type = SALT_TYPE_INTERN;
8015 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8016 opts_type = OPTS_TYPE_PT_GENERATE_BE
8017 | OPTS_TYPE_PT_ADD80
8018 | OPTS_TYPE_PT_ADDBITS15
8019 | OPTS_TYPE_PT_UNICODE;
8020 kern_type = KERN_TYPE_SHA512_SLTPWU;
8021 dgst_size = DGST_SIZE_8_8;
8022 parse_func = sha512s_parse_hash;
8023 sort_by_digest = sort_by_digest_8_8;
8024 opti_type = OPTI_TYPE_ZERO_BYTE
8025 | OPTI_TYPE_PRECOMPUTE_INIT
8026 | OPTI_TYPE_PRECOMPUTE_MERKLE
8027 | OPTI_TYPE_EARLY_SKIP
8028 | OPTI_TYPE_NOT_ITERATED
8029 | OPTI_TYPE_PREPENDED_SALT
8030 | OPTI_TYPE_USES_BITS_64
8031 | OPTI_TYPE_RAW_HASH;
8032 dgst_pos0 = 14;
8033 dgst_pos1 = 15;
8034 dgst_pos2 = 6;
8035 dgst_pos3 = 7;
8036 break;
8037
8038 case 1750: hash_type = HASH_TYPE_SHA512;
8039 salt_type = SALT_TYPE_INTERN;
8040 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8041 opts_type = OPTS_TYPE_PT_GENERATE_BE
8042 | OPTS_TYPE_ST_ADD80;
8043 kern_type = KERN_TYPE_HMACSHA512_PW;
8044 dgst_size = DGST_SIZE_8_8;
8045 parse_func = hmacsha512_parse_hash;
8046 sort_by_digest = sort_by_digest_8_8;
8047 opti_type = OPTI_TYPE_ZERO_BYTE
8048 | OPTI_TYPE_USES_BITS_64
8049 | OPTI_TYPE_NOT_ITERATED;
8050 dgst_pos0 = 14;
8051 dgst_pos1 = 15;
8052 dgst_pos2 = 6;
8053 dgst_pos3 = 7;
8054 break;
8055
8056 case 1760: hash_type = HASH_TYPE_SHA512;
8057 salt_type = SALT_TYPE_INTERN;
8058 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8059 opts_type = OPTS_TYPE_PT_GENERATE_BE
8060 | OPTS_TYPE_PT_ADD80
8061 | OPTS_TYPE_PT_ADDBITS15;
8062 kern_type = KERN_TYPE_HMACSHA512_SLT;
8063 dgst_size = DGST_SIZE_8_8;
8064 parse_func = hmacsha512_parse_hash;
8065 sort_by_digest = sort_by_digest_8_8;
8066 opti_type = OPTI_TYPE_ZERO_BYTE
8067 | OPTI_TYPE_USES_BITS_64
8068 | OPTI_TYPE_NOT_ITERATED;
8069 dgst_pos0 = 14;
8070 dgst_pos1 = 15;
8071 dgst_pos2 = 6;
8072 dgst_pos3 = 7;
8073 break;
8074
8075 case 1800: hash_type = HASH_TYPE_SHA512;
8076 salt_type = SALT_TYPE_EMBEDDED;
8077 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8078 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8079 kern_type = KERN_TYPE_SHA512CRYPT;
8080 dgst_size = DGST_SIZE_8_8;
8081 parse_func = sha512crypt_parse_hash;
8082 sort_by_digest = sort_by_digest_8_8;
8083 opti_type = OPTI_TYPE_ZERO_BYTE
8084 | OPTI_TYPE_USES_BITS_64;
8085 dgst_pos0 = 0;
8086 dgst_pos1 = 1;
8087 dgst_pos2 = 2;
8088 dgst_pos3 = 3;
8089 break;
8090
8091 case 2100: hash_type = HASH_TYPE_DCC2;
8092 salt_type = SALT_TYPE_EMBEDDED;
8093 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8094 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8095 | OPTS_TYPE_ST_LOWER
8096 | OPTS_TYPE_ST_UNICODE;
8097 kern_type = KERN_TYPE_DCC2;
8098 dgst_size = DGST_SIZE_4_4;
8099 parse_func = dcc2_parse_hash;
8100 sort_by_digest = sort_by_digest_4_4;
8101 opti_type = OPTI_TYPE_ZERO_BYTE
8102 | OPTI_TYPE_SLOW_HASH_SIMD;
8103 dgst_pos0 = 0;
8104 dgst_pos1 = 1;
8105 dgst_pos2 = 2;
8106 dgst_pos3 = 3;
8107 break;
8108
8109 case 2400: hash_type = HASH_TYPE_MD5;
8110 salt_type = SALT_TYPE_NONE;
8111 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8112 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8113 kern_type = KERN_TYPE_MD5PIX;
8114 dgst_size = DGST_SIZE_4_4;
8115 parse_func = md5pix_parse_hash;
8116 sort_by_digest = sort_by_digest_4_4;
8117 opti_type = OPTI_TYPE_ZERO_BYTE
8118 | OPTI_TYPE_PRECOMPUTE_INIT
8119 | OPTI_TYPE_PRECOMPUTE_MERKLE
8120 | OPTI_TYPE_EARLY_SKIP
8121 | OPTI_TYPE_NOT_ITERATED
8122 | OPTI_TYPE_NOT_SALTED;
8123 dgst_pos0 = 0;
8124 dgst_pos1 = 3;
8125 dgst_pos2 = 2;
8126 dgst_pos3 = 1;
8127 break;
8128
8129 case 2410: hash_type = HASH_TYPE_MD5;
8130 salt_type = SALT_TYPE_INTERN;
8131 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8132 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8133 kern_type = KERN_TYPE_MD5ASA;
8134 dgst_size = DGST_SIZE_4_4;
8135 parse_func = md5asa_parse_hash;
8136 sort_by_digest = sort_by_digest_4_4;
8137 opti_type = OPTI_TYPE_ZERO_BYTE
8138 | OPTI_TYPE_PRECOMPUTE_INIT
8139 | OPTI_TYPE_PRECOMPUTE_MERKLE
8140 | OPTI_TYPE_EARLY_SKIP
8141 | OPTI_TYPE_NOT_ITERATED;
8142 dgst_pos0 = 0;
8143 dgst_pos1 = 3;
8144 dgst_pos2 = 2;
8145 dgst_pos3 = 1;
8146 break;
8147
8148 case 2500: hash_type = HASH_TYPE_WPA;
8149 salt_type = SALT_TYPE_EMBEDDED;
8150 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8151 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8152 kern_type = KERN_TYPE_WPA;
8153 dgst_size = DGST_SIZE_4_4;
8154 parse_func = wpa_parse_hash;
8155 sort_by_digest = sort_by_digest_4_4;
8156 opti_type = OPTI_TYPE_ZERO_BYTE
8157 | OPTI_TYPE_SLOW_HASH_SIMD;
8158 dgst_pos0 = 0;
8159 dgst_pos1 = 1;
8160 dgst_pos2 = 2;
8161 dgst_pos3 = 3;
8162 break;
8163
8164 case 2600: hash_type = HASH_TYPE_MD5;
8165 salt_type = SALT_TYPE_VIRTUAL;
8166 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8167 opts_type = OPTS_TYPE_PT_GENERATE_LE
8168 | OPTS_TYPE_PT_ADD80
8169 | OPTS_TYPE_PT_ADDBITS14
8170 | OPTS_TYPE_ST_ADD80;
8171 kern_type = KERN_TYPE_MD55_PWSLT1;
8172 dgst_size = DGST_SIZE_4_4;
8173 parse_func = md5md5_parse_hash;
8174 sort_by_digest = sort_by_digest_4_4;
8175 opti_type = OPTI_TYPE_ZERO_BYTE
8176 | OPTI_TYPE_PRECOMPUTE_INIT
8177 | OPTI_TYPE_PRECOMPUTE_MERKLE
8178 | OPTI_TYPE_EARLY_SKIP;
8179 dgst_pos0 = 0;
8180 dgst_pos1 = 3;
8181 dgst_pos2 = 2;
8182 dgst_pos3 = 1;
8183 break;
8184
8185 case 2611: hash_type = HASH_TYPE_MD5;
8186 salt_type = SALT_TYPE_INTERN;
8187 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8188 opts_type = OPTS_TYPE_PT_GENERATE_LE
8189 | OPTS_TYPE_PT_ADD80
8190 | OPTS_TYPE_PT_ADDBITS14
8191 | OPTS_TYPE_ST_ADD80;
8192 kern_type = KERN_TYPE_MD55_PWSLT1;
8193 dgst_size = DGST_SIZE_4_4;
8194 parse_func = vb3_parse_hash;
8195 sort_by_digest = sort_by_digest_4_4;
8196 opti_type = OPTI_TYPE_ZERO_BYTE
8197 | OPTI_TYPE_PRECOMPUTE_INIT
8198 | OPTI_TYPE_PRECOMPUTE_MERKLE
8199 | OPTI_TYPE_EARLY_SKIP;
8200 dgst_pos0 = 0;
8201 dgst_pos1 = 3;
8202 dgst_pos2 = 2;
8203 dgst_pos3 = 1;
8204 break;
8205
8206 case 2612: hash_type = HASH_TYPE_MD5;
8207 salt_type = SALT_TYPE_EMBEDDED;
8208 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8209 opts_type = OPTS_TYPE_PT_GENERATE_LE
8210 | OPTS_TYPE_PT_ADD80
8211 | OPTS_TYPE_PT_ADDBITS14
8212 | OPTS_TYPE_ST_ADD80
8213 | OPTS_TYPE_ST_HEX;
8214 kern_type = KERN_TYPE_MD55_PWSLT1;
8215 dgst_size = DGST_SIZE_4_4;
8216 parse_func = phps_parse_hash;
8217 sort_by_digest = sort_by_digest_4_4;
8218 opti_type = OPTI_TYPE_ZERO_BYTE
8219 | OPTI_TYPE_PRECOMPUTE_INIT
8220 | OPTI_TYPE_PRECOMPUTE_MERKLE
8221 | OPTI_TYPE_EARLY_SKIP;
8222 dgst_pos0 = 0;
8223 dgst_pos1 = 3;
8224 dgst_pos2 = 2;
8225 dgst_pos3 = 1;
8226 break;
8227
8228 case 2711: hash_type = HASH_TYPE_MD5;
8229 salt_type = SALT_TYPE_INTERN;
8230 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8231 opts_type = OPTS_TYPE_PT_GENERATE_LE
8232 | OPTS_TYPE_PT_ADD80
8233 | OPTS_TYPE_PT_ADDBITS14
8234 | OPTS_TYPE_ST_ADD80;
8235 kern_type = KERN_TYPE_MD55_PWSLT2;
8236 dgst_size = DGST_SIZE_4_4;
8237 parse_func = vb30_parse_hash;
8238 sort_by_digest = sort_by_digest_4_4;
8239 opti_type = OPTI_TYPE_ZERO_BYTE
8240 | OPTI_TYPE_PRECOMPUTE_INIT
8241 | OPTI_TYPE_EARLY_SKIP;
8242 dgst_pos0 = 0;
8243 dgst_pos1 = 3;
8244 dgst_pos2 = 2;
8245 dgst_pos3 = 1;
8246 break;
8247
8248 case 2811: hash_type = HASH_TYPE_MD5;
8249 salt_type = SALT_TYPE_INTERN;
8250 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8251 opts_type = OPTS_TYPE_PT_GENERATE_LE
8252 | OPTS_TYPE_PT_ADD80
8253 | OPTS_TYPE_PT_ADDBITS14;
8254 kern_type = KERN_TYPE_MD55_SLTPW;
8255 dgst_size = DGST_SIZE_4_4;
8256 parse_func = ipb2_parse_hash;
8257 sort_by_digest = sort_by_digest_4_4;
8258 opti_type = OPTI_TYPE_ZERO_BYTE
8259 | OPTI_TYPE_PRECOMPUTE_INIT
8260 | OPTI_TYPE_EARLY_SKIP;
8261 dgst_pos0 = 0;
8262 dgst_pos1 = 3;
8263 dgst_pos2 = 2;
8264 dgst_pos3 = 1;
8265 break;
8266
8267 case 3000: hash_type = HASH_TYPE_LM;
8268 salt_type = SALT_TYPE_NONE;
8269 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8270 opts_type = OPTS_TYPE_PT_GENERATE_LE
8271 | OPTS_TYPE_PT_UPPER
8272 | OPTS_TYPE_PT_BITSLICE;
8273 kern_type = KERN_TYPE_LM;
8274 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8275 parse_func = lm_parse_hash;
8276 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8277 opti_type = OPTI_TYPE_ZERO_BYTE
8278 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8279 dgst_pos0 = 0;
8280 dgst_pos1 = 1;
8281 dgst_pos2 = 2;
8282 dgst_pos3 = 3;
8283 break;
8284
8285 case 3100: hash_type = HASH_TYPE_ORACLEH;
8286 salt_type = SALT_TYPE_INTERN;
8287 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8288 opts_type = OPTS_TYPE_PT_GENERATE_LE
8289 | OPTS_TYPE_PT_UPPER
8290 | OPTS_TYPE_ST_UPPER;
8291 kern_type = KERN_TYPE_ORACLEH;
8292 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8293 parse_func = oracleh_parse_hash;
8294 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8295 opti_type = OPTI_TYPE_ZERO_BYTE;
8296 dgst_pos0 = 0;
8297 dgst_pos1 = 1;
8298 dgst_pos2 = 2;
8299 dgst_pos3 = 3;
8300 break;
8301
8302 case 3200: hash_type = HASH_TYPE_BCRYPT;
8303 salt_type = SALT_TYPE_EMBEDDED;
8304 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8305 opts_type = OPTS_TYPE_PT_GENERATE_LE
8306 | OPTS_TYPE_ST_GENERATE_LE;
8307 kern_type = KERN_TYPE_BCRYPT;
8308 dgst_size = DGST_SIZE_4_6;
8309 parse_func = bcrypt_parse_hash;
8310 sort_by_digest = sort_by_digest_4_6;
8311 opti_type = OPTI_TYPE_ZERO_BYTE;
8312 dgst_pos0 = 0;
8313 dgst_pos1 = 1;
8314 dgst_pos2 = 2;
8315 dgst_pos3 = 3;
8316 break;
8317
8318 case 3710: hash_type = HASH_TYPE_MD5;
8319 salt_type = SALT_TYPE_INTERN;
8320 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8321 opts_type = OPTS_TYPE_PT_GENERATE_LE
8322 | OPTS_TYPE_PT_ADD80
8323 | OPTS_TYPE_PT_ADDBITS14;
8324 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8325 dgst_size = DGST_SIZE_4_4;
8326 parse_func = md5s_parse_hash;
8327 sort_by_digest = sort_by_digest_4_4;
8328 opti_type = OPTI_TYPE_ZERO_BYTE
8329 | OPTI_TYPE_PRECOMPUTE_INIT
8330 | OPTI_TYPE_PRECOMPUTE_MERKLE
8331 | OPTI_TYPE_EARLY_SKIP;
8332 dgst_pos0 = 0;
8333 dgst_pos1 = 3;
8334 dgst_pos2 = 2;
8335 dgst_pos3 = 1;
8336 break;
8337
8338 case 3711: hash_type = HASH_TYPE_MD5;
8339 salt_type = SALT_TYPE_EMBEDDED;
8340 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8341 opts_type = OPTS_TYPE_PT_GENERATE_LE
8342 | OPTS_TYPE_PT_ADD80
8343 | OPTS_TYPE_PT_ADDBITS14;
8344 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8345 dgst_size = DGST_SIZE_4_4;
8346 parse_func = mediawiki_b_parse_hash;
8347 sort_by_digest = sort_by_digest_4_4;
8348 opti_type = OPTI_TYPE_ZERO_BYTE
8349 | OPTI_TYPE_PRECOMPUTE_INIT
8350 | OPTI_TYPE_PRECOMPUTE_MERKLE
8351 | OPTI_TYPE_EARLY_SKIP;
8352 dgst_pos0 = 0;
8353 dgst_pos1 = 3;
8354 dgst_pos2 = 2;
8355 dgst_pos3 = 1;
8356 break;
8357
8358 case 3800: hash_type = HASH_TYPE_MD5;
8359 salt_type = SALT_TYPE_INTERN;
8360 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8361 opts_type = OPTS_TYPE_PT_GENERATE_LE
8362 | OPTS_TYPE_ST_ADDBITS14;
8363 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8364 dgst_size = DGST_SIZE_4_4;
8365 parse_func = md5s_parse_hash;
8366 sort_by_digest = sort_by_digest_4_4;
8367 opti_type = OPTI_TYPE_ZERO_BYTE
8368 | OPTI_TYPE_PRECOMPUTE_INIT
8369 | OPTI_TYPE_PRECOMPUTE_MERKLE
8370 | OPTI_TYPE_EARLY_SKIP
8371 | OPTI_TYPE_NOT_ITERATED
8372 | OPTI_TYPE_RAW_HASH;
8373 dgst_pos0 = 0;
8374 dgst_pos1 = 3;
8375 dgst_pos2 = 2;
8376 dgst_pos3 = 1;
8377 break;
8378
8379 case 4300: hash_type = HASH_TYPE_MD5;
8380 salt_type = SALT_TYPE_VIRTUAL;
8381 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8382 opts_type = OPTS_TYPE_PT_GENERATE_LE
8383 | OPTS_TYPE_PT_ADD80
8384 | OPTS_TYPE_PT_ADDBITS14
8385 | OPTS_TYPE_ST_ADD80;
8386 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8387 dgst_size = DGST_SIZE_4_4;
8388 parse_func = md5md5_parse_hash;
8389 sort_by_digest = sort_by_digest_4_4;
8390 opti_type = OPTI_TYPE_ZERO_BYTE
8391 | OPTI_TYPE_PRECOMPUTE_INIT
8392 | OPTI_TYPE_PRECOMPUTE_MERKLE
8393 | OPTI_TYPE_EARLY_SKIP;
8394 dgst_pos0 = 0;
8395 dgst_pos1 = 3;
8396 dgst_pos2 = 2;
8397 dgst_pos3 = 1;
8398 break;
8399
8400
8401 case 4400: hash_type = HASH_TYPE_MD5;
8402 salt_type = SALT_TYPE_NONE;
8403 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8404 opts_type = OPTS_TYPE_PT_GENERATE_BE
8405 | OPTS_TYPE_PT_ADD80
8406 | OPTS_TYPE_PT_ADDBITS15;
8407 kern_type = KERN_TYPE_MD5_SHA1;
8408 dgst_size = DGST_SIZE_4_4;
8409 parse_func = md5_parse_hash;
8410 sort_by_digest = sort_by_digest_4_4;
8411 opti_type = OPTI_TYPE_ZERO_BYTE
8412 | OPTI_TYPE_PRECOMPUTE_INIT
8413 | OPTI_TYPE_PRECOMPUTE_MERKLE
8414 | OPTI_TYPE_EARLY_SKIP
8415 | OPTI_TYPE_NOT_ITERATED
8416 | OPTI_TYPE_NOT_SALTED
8417 | OPTI_TYPE_RAW_HASH;
8418 dgst_pos0 = 0;
8419 dgst_pos1 = 3;
8420 dgst_pos2 = 2;
8421 dgst_pos3 = 1;
8422 break;
8423
8424 case 4500: hash_type = HASH_TYPE_SHA1;
8425 salt_type = SALT_TYPE_NONE;
8426 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8427 opts_type = OPTS_TYPE_PT_GENERATE_BE
8428 | OPTS_TYPE_PT_ADD80
8429 | OPTS_TYPE_PT_ADDBITS15;
8430 kern_type = KERN_TYPE_SHA11;
8431 dgst_size = DGST_SIZE_4_5;
8432 parse_func = sha1_parse_hash;
8433 sort_by_digest = sort_by_digest_4_5;
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_SALTED;
8439 dgst_pos0 = 3;
8440 dgst_pos1 = 4;
8441 dgst_pos2 = 2;
8442 dgst_pos3 = 1;
8443 break;
8444
8445 case 4700: hash_type = HASH_TYPE_SHA1;
8446 salt_type = SALT_TYPE_NONE;
8447 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8448 opts_type = OPTS_TYPE_PT_GENERATE_LE
8449 | OPTS_TYPE_PT_ADD80
8450 | OPTS_TYPE_PT_ADDBITS14;
8451 kern_type = KERN_TYPE_SHA1_MD5;
8452 dgst_size = DGST_SIZE_4_5;
8453 parse_func = sha1_parse_hash;
8454 sort_by_digest = sort_by_digest_4_5;
8455 opti_type = OPTI_TYPE_ZERO_BYTE
8456 | OPTI_TYPE_PRECOMPUTE_INIT
8457 | OPTI_TYPE_PRECOMPUTE_MERKLE
8458 | OPTI_TYPE_EARLY_SKIP
8459 | OPTI_TYPE_NOT_ITERATED
8460 | OPTI_TYPE_NOT_SALTED
8461 | OPTI_TYPE_RAW_HASH;
8462 dgst_pos0 = 3;
8463 dgst_pos1 = 4;
8464 dgst_pos2 = 2;
8465 dgst_pos3 = 1;
8466 break;
8467
8468 case 4800: hash_type = HASH_TYPE_MD5;
8469 salt_type = SALT_TYPE_EMBEDDED;
8470 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8471 opts_type = OPTS_TYPE_PT_GENERATE_LE
8472 | OPTS_TYPE_PT_ADDBITS14;
8473 kern_type = KERN_TYPE_MD5_CHAP;
8474 dgst_size = DGST_SIZE_4_4;
8475 parse_func = chap_parse_hash;
8476 sort_by_digest = sort_by_digest_4_4;
8477 opti_type = OPTI_TYPE_ZERO_BYTE
8478 | OPTI_TYPE_PRECOMPUTE_INIT
8479 | OPTI_TYPE_PRECOMPUTE_MERKLE
8480 | OPTI_TYPE_MEET_IN_MIDDLE
8481 | OPTI_TYPE_EARLY_SKIP
8482 | OPTI_TYPE_NOT_ITERATED
8483 | OPTI_TYPE_RAW_HASH;
8484 dgst_pos0 = 0;
8485 dgst_pos1 = 3;
8486 dgst_pos2 = 2;
8487 dgst_pos3 = 1;
8488 break;
8489
8490 case 4900: hash_type = HASH_TYPE_SHA1;
8491 salt_type = SALT_TYPE_INTERN;
8492 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8493 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8494 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8495 dgst_size = DGST_SIZE_4_5;
8496 parse_func = sha1s_parse_hash;
8497 sort_by_digest = sort_by_digest_4_5;
8498 opti_type = OPTI_TYPE_ZERO_BYTE
8499 | OPTI_TYPE_PRECOMPUTE_INIT
8500 | OPTI_TYPE_PRECOMPUTE_MERKLE
8501 | OPTI_TYPE_EARLY_SKIP;
8502 dgst_pos0 = 3;
8503 dgst_pos1 = 4;
8504 dgst_pos2 = 2;
8505 dgst_pos3 = 1;
8506 break;
8507
8508 case 5000: hash_type = HASH_TYPE_KECCAK;
8509 salt_type = SALT_TYPE_EMBEDDED;
8510 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8511 opts_type = OPTS_TYPE_PT_GENERATE_LE
8512 | OPTS_TYPE_PT_ADD01;
8513 kern_type = KERN_TYPE_KECCAK;
8514 dgst_size = DGST_SIZE_8_25;
8515 parse_func = keccak_parse_hash;
8516 sort_by_digest = sort_by_digest_8_25;
8517 opti_type = OPTI_TYPE_ZERO_BYTE
8518 | OPTI_TYPE_USES_BITS_64
8519 | OPTI_TYPE_RAW_HASH;
8520 dgst_pos0 = 2;
8521 dgst_pos1 = 3;
8522 dgst_pos2 = 4;
8523 dgst_pos3 = 5;
8524 break;
8525
8526 case 5100: hash_type = HASH_TYPE_MD5H;
8527 salt_type = SALT_TYPE_NONE;
8528 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8529 opts_type = OPTS_TYPE_PT_GENERATE_LE
8530 | OPTS_TYPE_PT_ADD80
8531 | OPTS_TYPE_PT_ADDBITS14;
8532 kern_type = KERN_TYPE_MD5H;
8533 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8534 parse_func = md5half_parse_hash;
8535 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8536 opti_type = OPTI_TYPE_ZERO_BYTE
8537 | OPTI_TYPE_RAW_HASH;
8538 dgst_pos0 = 0;
8539 dgst_pos1 = 1;
8540 dgst_pos2 = 2;
8541 dgst_pos3 = 3;
8542 break;
8543
8544 case 5200: hash_type = HASH_TYPE_SHA256;
8545 salt_type = SALT_TYPE_EMBEDDED;
8546 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8547 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8548 kern_type = KERN_TYPE_PSAFE3;
8549 dgst_size = DGST_SIZE_4_8;
8550 parse_func = psafe3_parse_hash;
8551 sort_by_digest = sort_by_digest_4_8;
8552 opti_type = OPTI_TYPE_ZERO_BYTE;
8553 dgst_pos0 = 0;
8554 dgst_pos1 = 1;
8555 dgst_pos2 = 2;
8556 dgst_pos3 = 3;
8557 break;
8558
8559 case 5300: hash_type = HASH_TYPE_MD5;
8560 salt_type = SALT_TYPE_EMBEDDED;
8561 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8562 opts_type = OPTS_TYPE_PT_GENERATE_LE
8563 | OPTS_TYPE_ST_ADD80;
8564 kern_type = KERN_TYPE_IKEPSK_MD5;
8565 dgst_size = DGST_SIZE_4_4;
8566 parse_func = ikepsk_md5_parse_hash;
8567 sort_by_digest = sort_by_digest_4_4;
8568 opti_type = OPTI_TYPE_ZERO_BYTE;
8569 dgst_pos0 = 0;
8570 dgst_pos1 = 3;
8571 dgst_pos2 = 2;
8572 dgst_pos3 = 1;
8573 break;
8574
8575 case 5400: hash_type = HASH_TYPE_SHA1;
8576 salt_type = SALT_TYPE_EMBEDDED;
8577 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8578 opts_type = OPTS_TYPE_PT_GENERATE_BE
8579 | OPTS_TYPE_ST_ADD80;
8580 kern_type = KERN_TYPE_IKEPSK_SHA1;
8581 dgst_size = DGST_SIZE_4_5;
8582 parse_func = ikepsk_sha1_parse_hash;
8583 sort_by_digest = sort_by_digest_4_5;
8584 opti_type = OPTI_TYPE_ZERO_BYTE;
8585 dgst_pos0 = 3;
8586 dgst_pos1 = 4;
8587 dgst_pos2 = 2;
8588 dgst_pos3 = 1;
8589 break;
8590
8591 case 5500: hash_type = HASH_TYPE_NETNTLM;
8592 salt_type = SALT_TYPE_EMBEDDED;
8593 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8594 opts_type = OPTS_TYPE_PT_GENERATE_LE
8595 | OPTS_TYPE_PT_ADD80
8596 | OPTS_TYPE_PT_ADDBITS14
8597 | OPTS_TYPE_PT_UNICODE
8598 | OPTS_TYPE_ST_HEX;
8599 kern_type = KERN_TYPE_NETNTLMv1;
8600 dgst_size = DGST_SIZE_4_4;
8601 parse_func = netntlmv1_parse_hash;
8602 sort_by_digest = sort_by_digest_4_4;
8603 opti_type = OPTI_TYPE_ZERO_BYTE
8604 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8605 dgst_pos0 = 0;
8606 dgst_pos1 = 1;
8607 dgst_pos2 = 2;
8608 dgst_pos3 = 3;
8609 break;
8610
8611 case 5600: hash_type = HASH_TYPE_MD5;
8612 salt_type = SALT_TYPE_EMBEDDED;
8613 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8614 opts_type = OPTS_TYPE_PT_GENERATE_LE
8615 | OPTS_TYPE_PT_ADD80
8616 | OPTS_TYPE_PT_ADDBITS14
8617 | OPTS_TYPE_PT_UNICODE;
8618 kern_type = KERN_TYPE_NETNTLMv2;
8619 dgst_size = DGST_SIZE_4_4;
8620 parse_func = netntlmv2_parse_hash;
8621 sort_by_digest = sort_by_digest_4_4;
8622 opti_type = OPTI_TYPE_ZERO_BYTE;
8623 dgst_pos0 = 0;
8624 dgst_pos1 = 3;
8625 dgst_pos2 = 2;
8626 dgst_pos3 = 1;
8627 break;
8628
8629 case 5700: hash_type = HASH_TYPE_SHA256;
8630 salt_type = SALT_TYPE_NONE;
8631 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8632 opts_type = OPTS_TYPE_PT_GENERATE_BE
8633 | OPTS_TYPE_PT_ADD80
8634 | OPTS_TYPE_PT_ADDBITS15;
8635 kern_type = KERN_TYPE_SHA256;
8636 dgst_size = DGST_SIZE_4_8;
8637 parse_func = cisco4_parse_hash;
8638 sort_by_digest = sort_by_digest_4_8;
8639 opti_type = OPTI_TYPE_ZERO_BYTE
8640 | OPTI_TYPE_PRECOMPUTE_INIT
8641 | OPTI_TYPE_PRECOMPUTE_MERKLE
8642 | OPTI_TYPE_EARLY_SKIP
8643 | OPTI_TYPE_NOT_ITERATED
8644 | OPTI_TYPE_NOT_SALTED
8645 | OPTI_TYPE_RAW_HASH;
8646 dgst_pos0 = 3;
8647 dgst_pos1 = 7;
8648 dgst_pos2 = 2;
8649 dgst_pos3 = 6;
8650 break;
8651
8652 case 5800: hash_type = HASH_TYPE_SHA1;
8653 salt_type = SALT_TYPE_INTERN;
8654 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8655 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8656 | OPTS_TYPE_ST_ADD80;
8657 kern_type = KERN_TYPE_ANDROIDPIN;
8658 dgst_size = DGST_SIZE_4_5;
8659 parse_func = androidpin_parse_hash;
8660 sort_by_digest = sort_by_digest_4_5;
8661 opti_type = OPTI_TYPE_ZERO_BYTE;
8662 dgst_pos0 = 0;
8663 dgst_pos1 = 1;
8664 dgst_pos2 = 2;
8665 dgst_pos3 = 3;
8666 break;
8667
8668 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8669 salt_type = SALT_TYPE_NONE;
8670 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8671 opts_type = OPTS_TYPE_PT_GENERATE_LE
8672 | OPTS_TYPE_PT_ADD80;
8673 kern_type = KERN_TYPE_RIPEMD160;
8674 dgst_size = DGST_SIZE_4_5;
8675 parse_func = ripemd160_parse_hash;
8676 sort_by_digest = sort_by_digest_4_5;
8677 opti_type = OPTI_TYPE_ZERO_BYTE;
8678 dgst_pos0 = 0;
8679 dgst_pos1 = 1;
8680 dgst_pos2 = 2;
8681 dgst_pos3 = 3;
8682 break;
8683
8684 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8685 salt_type = SALT_TYPE_NONE;
8686 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8687 opts_type = OPTS_TYPE_PT_GENERATE_BE
8688 | OPTS_TYPE_PT_ADD80;
8689 kern_type = KERN_TYPE_WHIRLPOOL;
8690 dgst_size = DGST_SIZE_4_16;
8691 parse_func = whirlpool_parse_hash;
8692 sort_by_digest = sort_by_digest_4_16;
8693 opti_type = OPTI_TYPE_ZERO_BYTE;
8694 dgst_pos0 = 0;
8695 dgst_pos1 = 1;
8696 dgst_pos2 = 2;
8697 dgst_pos3 = 3;
8698 break;
8699
8700 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8701 salt_type = SALT_TYPE_EMBEDDED;
8702 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8703 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8704 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8705 dgst_size = DGST_SIZE_4_5;
8706 parse_func = truecrypt_parse_hash_2k;
8707 sort_by_digest = sort_by_digest_4_5;
8708 opti_type = OPTI_TYPE_ZERO_BYTE;
8709 dgst_pos0 = 0;
8710 dgst_pos1 = 1;
8711 dgst_pos2 = 2;
8712 dgst_pos3 = 3;
8713 break;
8714
8715 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8716 salt_type = SALT_TYPE_EMBEDDED;
8717 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8718 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8719 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8720 dgst_size = DGST_SIZE_4_5;
8721 parse_func = truecrypt_parse_hash_2k;
8722 sort_by_digest = sort_by_digest_4_5;
8723 opti_type = OPTI_TYPE_ZERO_BYTE;
8724 dgst_pos0 = 0;
8725 dgst_pos1 = 1;
8726 dgst_pos2 = 2;
8727 dgst_pos3 = 3;
8728 break;
8729
8730 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8731 salt_type = SALT_TYPE_EMBEDDED;
8732 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8733 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8734 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8735 dgst_size = DGST_SIZE_4_5;
8736 parse_func = truecrypt_parse_hash_2k;
8737 sort_by_digest = sort_by_digest_4_5;
8738 opti_type = OPTI_TYPE_ZERO_BYTE;
8739 dgst_pos0 = 0;
8740 dgst_pos1 = 1;
8741 dgst_pos2 = 2;
8742 dgst_pos3 = 3;
8743 break;
8744
8745 case 6221: hash_type = HASH_TYPE_SHA512;
8746 salt_type = SALT_TYPE_EMBEDDED;
8747 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8748 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8749 kern_type = KERN_TYPE_TCSHA512_XTS512;
8750 dgst_size = DGST_SIZE_8_8;
8751 parse_func = truecrypt_parse_hash_1k;
8752 sort_by_digest = sort_by_digest_8_8;
8753 opti_type = OPTI_TYPE_ZERO_BYTE
8754 | OPTI_TYPE_USES_BITS_64;
8755 dgst_pos0 = 0;
8756 dgst_pos1 = 1;
8757 dgst_pos2 = 2;
8758 dgst_pos3 = 3;
8759 break;
8760
8761 case 6222: hash_type = HASH_TYPE_SHA512;
8762 salt_type = SALT_TYPE_EMBEDDED;
8763 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8764 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8765 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8766 dgst_size = DGST_SIZE_8_8;
8767 parse_func = truecrypt_parse_hash_1k;
8768 sort_by_digest = sort_by_digest_8_8;
8769 opti_type = OPTI_TYPE_ZERO_BYTE
8770 | OPTI_TYPE_USES_BITS_64;
8771 dgst_pos0 = 0;
8772 dgst_pos1 = 1;
8773 dgst_pos2 = 2;
8774 dgst_pos3 = 3;
8775 break;
8776
8777 case 6223: hash_type = HASH_TYPE_SHA512;
8778 salt_type = SALT_TYPE_EMBEDDED;
8779 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8780 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8781 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8782 dgst_size = DGST_SIZE_8_8;
8783 parse_func = truecrypt_parse_hash_1k;
8784 sort_by_digest = sort_by_digest_8_8;
8785 opti_type = OPTI_TYPE_ZERO_BYTE
8786 | OPTI_TYPE_USES_BITS_64;
8787 dgst_pos0 = 0;
8788 dgst_pos1 = 1;
8789 dgst_pos2 = 2;
8790 dgst_pos3 = 3;
8791 break;
8792
8793 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8794 salt_type = SALT_TYPE_EMBEDDED;
8795 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8796 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8797 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8798 dgst_size = DGST_SIZE_4_8;
8799 parse_func = truecrypt_parse_hash_1k;
8800 sort_by_digest = sort_by_digest_4_8;
8801 opti_type = OPTI_TYPE_ZERO_BYTE;
8802 dgst_pos0 = 0;
8803 dgst_pos1 = 1;
8804 dgst_pos2 = 2;
8805 dgst_pos3 = 3;
8806 break;
8807
8808 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8809 salt_type = SALT_TYPE_EMBEDDED;
8810 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8811 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8812 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8813 dgst_size = DGST_SIZE_4_8;
8814 parse_func = truecrypt_parse_hash_1k;
8815 sort_by_digest = sort_by_digest_4_8;
8816 opti_type = OPTI_TYPE_ZERO_BYTE;
8817 dgst_pos0 = 0;
8818 dgst_pos1 = 1;
8819 dgst_pos2 = 2;
8820 dgst_pos3 = 3;
8821 break;
8822
8823 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8824 salt_type = SALT_TYPE_EMBEDDED;
8825 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8826 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8827 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8828 dgst_size = DGST_SIZE_4_8;
8829 parse_func = truecrypt_parse_hash_1k;
8830 sort_by_digest = sort_by_digest_4_8;
8831 opti_type = OPTI_TYPE_ZERO_BYTE;
8832 dgst_pos0 = 0;
8833 dgst_pos1 = 1;
8834 dgst_pos2 = 2;
8835 dgst_pos3 = 3;
8836 break;
8837
8838 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8839 salt_type = SALT_TYPE_EMBEDDED;
8840 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8841 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8842 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8843 dgst_size = DGST_SIZE_4_5;
8844 parse_func = truecrypt_parse_hash_1k;
8845 sort_by_digest = sort_by_digest_4_5;
8846 opti_type = OPTI_TYPE_ZERO_BYTE;
8847 dgst_pos0 = 0;
8848 dgst_pos1 = 1;
8849 dgst_pos2 = 2;
8850 dgst_pos3 = 3;
8851 break;
8852
8853 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8854 salt_type = SALT_TYPE_EMBEDDED;
8855 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8856 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8857 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8858 dgst_size = DGST_SIZE_4_5;
8859 parse_func = truecrypt_parse_hash_1k;
8860 sort_by_digest = sort_by_digest_4_5;
8861 opti_type = OPTI_TYPE_ZERO_BYTE;
8862 dgst_pos0 = 0;
8863 dgst_pos1 = 1;
8864 dgst_pos2 = 2;
8865 dgst_pos3 = 3;
8866 break;
8867
8868 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8869 salt_type = SALT_TYPE_EMBEDDED;
8870 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8871 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8872 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8873 dgst_size = DGST_SIZE_4_5;
8874 parse_func = truecrypt_parse_hash_1k;
8875 sort_by_digest = sort_by_digest_4_5;
8876 opti_type = OPTI_TYPE_ZERO_BYTE;
8877 dgst_pos0 = 0;
8878 dgst_pos1 = 1;
8879 dgst_pos2 = 2;
8880 dgst_pos3 = 3;
8881 break;
8882
8883 case 6300: hash_type = HASH_TYPE_MD5;
8884 salt_type = SALT_TYPE_EMBEDDED;
8885 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8886 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8887 kern_type = KERN_TYPE_MD5AIX;
8888 dgst_size = DGST_SIZE_4_4;
8889 parse_func = md5aix_parse_hash;
8890 sort_by_digest = sort_by_digest_4_4;
8891 opti_type = OPTI_TYPE_ZERO_BYTE;
8892 dgst_pos0 = 0;
8893 dgst_pos1 = 1;
8894 dgst_pos2 = 2;
8895 dgst_pos3 = 3;
8896 break;
8897
8898 case 6400: hash_type = HASH_TYPE_SHA256;
8899 salt_type = SALT_TYPE_EMBEDDED;
8900 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8901 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8902 kern_type = KERN_TYPE_SHA256AIX;
8903 dgst_size = DGST_SIZE_4_8;
8904 parse_func = sha256aix_parse_hash;
8905 sort_by_digest = sort_by_digest_4_8;
8906 opti_type = OPTI_TYPE_ZERO_BYTE;
8907 dgst_pos0 = 0;
8908 dgst_pos1 = 1;
8909 dgst_pos2 = 2;
8910 dgst_pos3 = 3;
8911 break;
8912
8913 case 6500: hash_type = HASH_TYPE_SHA512;
8914 salt_type = SALT_TYPE_EMBEDDED;
8915 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8916 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8917 kern_type = KERN_TYPE_SHA512AIX;
8918 dgst_size = DGST_SIZE_8_8;
8919 parse_func = sha512aix_parse_hash;
8920 sort_by_digest = sort_by_digest_8_8;
8921 opti_type = OPTI_TYPE_ZERO_BYTE
8922 | OPTI_TYPE_USES_BITS_64;
8923 dgst_pos0 = 0;
8924 dgst_pos1 = 1;
8925 dgst_pos2 = 2;
8926 dgst_pos3 = 3;
8927 break;
8928
8929 case 6600: hash_type = HASH_TYPE_AES;
8930 salt_type = SALT_TYPE_EMBEDDED;
8931 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8932 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8933 kern_type = KERN_TYPE_AGILEKEY;
8934 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
8935 parse_func = agilekey_parse_hash;
8936 sort_by_digest = sort_by_digest_4_5;
8937 opti_type = OPTI_TYPE_ZERO_BYTE;
8938 dgst_pos0 = 0;
8939 dgst_pos1 = 1;
8940 dgst_pos2 = 2;
8941 dgst_pos3 = 3;
8942 break;
8943
8944 case 6700: hash_type = HASH_TYPE_SHA1;
8945 salt_type = SALT_TYPE_EMBEDDED;
8946 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8947 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8948 kern_type = KERN_TYPE_SHA1AIX;
8949 dgst_size = DGST_SIZE_4_5;
8950 parse_func = sha1aix_parse_hash;
8951 sort_by_digest = sort_by_digest_4_5;
8952 opti_type = OPTI_TYPE_ZERO_BYTE;
8953 dgst_pos0 = 0;
8954 dgst_pos1 = 1;
8955 dgst_pos2 = 2;
8956 dgst_pos3 = 3;
8957 break;
8958
8959 case 6800: hash_type = HASH_TYPE_AES;
8960 salt_type = SALT_TYPE_EMBEDDED;
8961 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8962 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8963 kern_type = KERN_TYPE_LASTPASS;
8964 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
8965 parse_func = lastpass_parse_hash;
8966 sort_by_digest = sort_by_digest_4_8;
8967 opti_type = OPTI_TYPE_ZERO_BYTE;
8968 dgst_pos0 = 0;
8969 dgst_pos1 = 1;
8970 dgst_pos2 = 2;
8971 dgst_pos3 = 3;
8972 break;
8973
8974 case 6900: hash_type = HASH_TYPE_GOST;
8975 salt_type = SALT_TYPE_NONE;
8976 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8977 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8978 kern_type = KERN_TYPE_GOST;
8979 dgst_size = DGST_SIZE_4_8;
8980 parse_func = gost_parse_hash;
8981 sort_by_digest = sort_by_digest_4_8;
8982 opti_type = OPTI_TYPE_ZERO_BYTE;
8983 dgst_pos0 = 0;
8984 dgst_pos1 = 1;
8985 dgst_pos2 = 2;
8986 dgst_pos3 = 3;
8987 break;
8988
8989 case 7100: hash_type = HASH_TYPE_SHA512;
8990 salt_type = SALT_TYPE_EMBEDDED;
8991 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8992 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8993 kern_type = KERN_TYPE_PBKDF2_SHA512;
8994 dgst_size = DGST_SIZE_8_16;
8995 parse_func = sha512osx_parse_hash;
8996 sort_by_digest = sort_by_digest_8_16;
8997 opti_type = OPTI_TYPE_ZERO_BYTE
8998 | OPTI_TYPE_USES_BITS_64
8999 | OPTI_TYPE_SLOW_HASH_SIMD;
9000 dgst_pos0 = 0;
9001 dgst_pos1 = 1;
9002 dgst_pos2 = 2;
9003 dgst_pos3 = 3;
9004 break;
9005
9006 case 7200: hash_type = HASH_TYPE_SHA512;
9007 salt_type = SALT_TYPE_EMBEDDED;
9008 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9009 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9010 kern_type = KERN_TYPE_PBKDF2_SHA512;
9011 dgst_size = DGST_SIZE_8_16;
9012 parse_func = sha512grub_parse_hash;
9013 sort_by_digest = sort_by_digest_8_16;
9014 opti_type = OPTI_TYPE_ZERO_BYTE
9015 | OPTI_TYPE_USES_BITS_64
9016 | OPTI_TYPE_SLOW_HASH_SIMD;
9017 dgst_pos0 = 0;
9018 dgst_pos1 = 1;
9019 dgst_pos2 = 2;
9020 dgst_pos3 = 3;
9021 break;
9022
9023 case 7300: hash_type = HASH_TYPE_SHA1;
9024 salt_type = SALT_TYPE_EMBEDDED;
9025 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9026 opts_type = OPTS_TYPE_PT_GENERATE_BE
9027 | OPTS_TYPE_ST_ADD80
9028 | OPTS_TYPE_ST_ADDBITS15;
9029 kern_type = KERN_TYPE_RAKP;
9030 dgst_size = DGST_SIZE_4_5;
9031 parse_func = rakp_parse_hash;
9032 sort_by_digest = sort_by_digest_4_5;
9033 opti_type = OPTI_TYPE_ZERO_BYTE
9034 | OPTI_TYPE_NOT_ITERATED;
9035 dgst_pos0 = 3;
9036 dgst_pos1 = 4;
9037 dgst_pos2 = 2;
9038 dgst_pos3 = 1;
9039 break;
9040
9041 case 7400: hash_type = HASH_TYPE_SHA256;
9042 salt_type = SALT_TYPE_EMBEDDED;
9043 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9044 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9045 kern_type = KERN_TYPE_SHA256CRYPT;
9046 dgst_size = DGST_SIZE_4_8;
9047 parse_func = sha256crypt_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 7500: hash_type = HASH_TYPE_KRB5PA;
9057 salt_type = SALT_TYPE_EMBEDDED;
9058 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9059 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9060 kern_type = KERN_TYPE_KRB5PA;
9061 dgst_size = DGST_SIZE_4_4;
9062 parse_func = krb5pa_parse_hash;
9063 sort_by_digest = sort_by_digest_4_4;
9064 opti_type = OPTI_TYPE_ZERO_BYTE
9065 | OPTI_TYPE_NOT_ITERATED;
9066 dgst_pos0 = 0;
9067 dgst_pos1 = 1;
9068 dgst_pos2 = 2;
9069 dgst_pos3 = 3;
9070 break;
9071
9072 case 7600: hash_type = HASH_TYPE_SHA1;
9073 salt_type = SALT_TYPE_INTERN;
9074 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9075 opts_type = OPTS_TYPE_PT_GENERATE_BE
9076 | OPTS_TYPE_PT_ADD80
9077 | OPTS_TYPE_PT_ADDBITS15;
9078 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9079 dgst_size = DGST_SIZE_4_5;
9080 parse_func = redmine_parse_hash;
9081 sort_by_digest = sort_by_digest_4_5;
9082 opti_type = OPTI_TYPE_ZERO_BYTE
9083 | OPTI_TYPE_PRECOMPUTE_INIT
9084 | OPTI_TYPE_EARLY_SKIP
9085 | OPTI_TYPE_NOT_ITERATED
9086 | OPTI_TYPE_PREPENDED_SALT;
9087 dgst_pos0 = 3;
9088 dgst_pos1 = 4;
9089 dgst_pos2 = 2;
9090 dgst_pos3 = 1;
9091 break;
9092
9093 case 7700: hash_type = HASH_TYPE_SAPB;
9094 salt_type = SALT_TYPE_EMBEDDED;
9095 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9096 opts_type = OPTS_TYPE_PT_GENERATE_LE
9097 | OPTS_TYPE_PT_UPPER
9098 | OPTS_TYPE_ST_UPPER;
9099 kern_type = KERN_TYPE_SAPB;
9100 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9101 parse_func = sapb_parse_hash;
9102 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9103 opti_type = OPTI_TYPE_ZERO_BYTE
9104 | OPTI_TYPE_PRECOMPUTE_INIT
9105 | OPTI_TYPE_NOT_ITERATED;
9106 dgst_pos0 = 0;
9107 dgst_pos1 = 1;
9108 dgst_pos2 = 2;
9109 dgst_pos3 = 3;
9110 break;
9111
9112 case 7800: hash_type = HASH_TYPE_SAPG;
9113 salt_type = SALT_TYPE_EMBEDDED;
9114 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9115 opts_type = OPTS_TYPE_PT_GENERATE_BE
9116 | OPTS_TYPE_ST_ADD80
9117 | OPTS_TYPE_ST_UPPER;
9118 kern_type = KERN_TYPE_SAPG;
9119 dgst_size = DGST_SIZE_4_5;
9120 parse_func = sapg_parse_hash;
9121 sort_by_digest = sort_by_digest_4_5;
9122 opti_type = OPTI_TYPE_ZERO_BYTE
9123 | OPTI_TYPE_PRECOMPUTE_INIT
9124 | OPTI_TYPE_NOT_ITERATED;
9125 dgst_pos0 = 3;
9126 dgst_pos1 = 4;
9127 dgst_pos2 = 2;
9128 dgst_pos3 = 1;
9129 break;
9130
9131 case 7900: hash_type = HASH_TYPE_SHA512;
9132 salt_type = SALT_TYPE_EMBEDDED;
9133 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9134 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9135 kern_type = KERN_TYPE_DRUPAL7;
9136 dgst_size = DGST_SIZE_8_8;
9137 parse_func = drupal7_parse_hash;
9138 sort_by_digest = sort_by_digest_8_8;
9139 opti_type = OPTI_TYPE_ZERO_BYTE
9140 | OPTI_TYPE_USES_BITS_64;
9141 dgst_pos0 = 0;
9142 dgst_pos1 = 1;
9143 dgst_pos2 = 2;
9144 dgst_pos3 = 3;
9145 break;
9146
9147 case 8000: hash_type = HASH_TYPE_SHA256;
9148 salt_type = SALT_TYPE_EMBEDDED;
9149 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9150 opts_type = OPTS_TYPE_PT_GENERATE_BE
9151 | OPTS_TYPE_PT_UNICODE
9152 | OPTS_TYPE_ST_ADD80
9153 | OPTS_TYPE_ST_HEX;
9154 kern_type = KERN_TYPE_SYBASEASE;
9155 dgst_size = DGST_SIZE_4_8;
9156 parse_func = sybasease_parse_hash;
9157 sort_by_digest = sort_by_digest_4_8;
9158 opti_type = OPTI_TYPE_ZERO_BYTE
9159 | OPTI_TYPE_PRECOMPUTE_INIT
9160 | OPTI_TYPE_EARLY_SKIP
9161 | OPTI_TYPE_NOT_ITERATED
9162 | OPTI_TYPE_RAW_HASH;
9163 dgst_pos0 = 3;
9164 dgst_pos1 = 7;
9165 dgst_pos2 = 2;
9166 dgst_pos3 = 6;
9167 break;
9168
9169 case 8100: hash_type = HASH_TYPE_SHA1;
9170 salt_type = SALT_TYPE_EMBEDDED;
9171 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9172 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9173 kern_type = KERN_TYPE_NETSCALER;
9174 dgst_size = DGST_SIZE_4_5;
9175 parse_func = netscaler_parse_hash;
9176 sort_by_digest = sort_by_digest_4_5;
9177 opti_type = OPTI_TYPE_ZERO_BYTE
9178 | OPTI_TYPE_PRECOMPUTE_INIT
9179 | OPTI_TYPE_PRECOMPUTE_MERKLE
9180 | OPTI_TYPE_EARLY_SKIP
9181 | OPTI_TYPE_NOT_ITERATED
9182 | OPTI_TYPE_PREPENDED_SALT
9183 | OPTI_TYPE_RAW_HASH;
9184 dgst_pos0 = 3;
9185 dgst_pos1 = 4;
9186 dgst_pos2 = 2;
9187 dgst_pos3 = 1;
9188 break;
9189
9190 case 8200: hash_type = HASH_TYPE_SHA256;
9191 salt_type = SALT_TYPE_EMBEDDED;
9192 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9193 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9194 kern_type = KERN_TYPE_CLOUDKEY;
9195 dgst_size = DGST_SIZE_4_8;
9196 parse_func = cloudkey_parse_hash;
9197 sort_by_digest = sort_by_digest_4_8;
9198 opti_type = OPTI_TYPE_ZERO_BYTE;
9199 dgst_pos0 = 0;
9200 dgst_pos1 = 1;
9201 dgst_pos2 = 2;
9202 dgst_pos3 = 3;
9203 break;
9204
9205 case 8300: hash_type = HASH_TYPE_SHA1;
9206 salt_type = SALT_TYPE_EMBEDDED;
9207 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9208 opts_type = OPTS_TYPE_PT_GENERATE_BE
9209 | OPTS_TYPE_ST_HEX
9210 | OPTS_TYPE_ST_ADD80;
9211 kern_type = KERN_TYPE_NSEC3;
9212 dgst_size = DGST_SIZE_4_5;
9213 parse_func = nsec3_parse_hash;
9214 sort_by_digest = sort_by_digest_4_5;
9215 opti_type = OPTI_TYPE_ZERO_BYTE;
9216 dgst_pos0 = 3;
9217 dgst_pos1 = 4;
9218 dgst_pos2 = 2;
9219 dgst_pos3 = 1;
9220 break;
9221
9222 case 8400: hash_type = HASH_TYPE_SHA1;
9223 salt_type = SALT_TYPE_INTERN;
9224 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9225 opts_type = OPTS_TYPE_PT_GENERATE_BE
9226 | OPTS_TYPE_PT_ADD80
9227 | OPTS_TYPE_PT_ADDBITS15;
9228 kern_type = KERN_TYPE_WBB3;
9229 dgst_size = DGST_SIZE_4_5;
9230 parse_func = wbb3_parse_hash;
9231 sort_by_digest = sort_by_digest_4_5;
9232 opti_type = OPTI_TYPE_ZERO_BYTE
9233 | OPTI_TYPE_PRECOMPUTE_INIT
9234 | OPTI_TYPE_NOT_ITERATED;
9235 dgst_pos0 = 3;
9236 dgst_pos1 = 4;
9237 dgst_pos2 = 2;
9238 dgst_pos3 = 1;
9239 break;
9240
9241 case 8500: hash_type = HASH_TYPE_DESRACF;
9242 salt_type = SALT_TYPE_EMBEDDED;
9243 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9244 opts_type = OPTS_TYPE_PT_GENERATE_LE
9245 | OPTS_TYPE_ST_UPPER;
9246 kern_type = KERN_TYPE_RACF;
9247 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9248 parse_func = racf_parse_hash;
9249 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9250 opti_type = OPTI_TYPE_ZERO_BYTE
9251 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9252 dgst_pos0 = 0;
9253 dgst_pos1 = 1;
9254 dgst_pos2 = 2;
9255 dgst_pos3 = 3;
9256 break;
9257
9258 case 8600: hash_type = HASH_TYPE_LOTUS5;
9259 salt_type = SALT_TYPE_NONE;
9260 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9261 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9262 kern_type = KERN_TYPE_LOTUS5;
9263 dgst_size = DGST_SIZE_4_4;
9264 parse_func = lotus5_parse_hash;
9265 sort_by_digest = sort_by_digest_4_4;
9266 opti_type = OPTI_TYPE_EARLY_SKIP
9267 | OPTI_TYPE_NOT_ITERATED
9268 | OPTI_TYPE_NOT_SALTED
9269 | OPTI_TYPE_RAW_HASH;
9270 dgst_pos0 = 0;
9271 dgst_pos1 = 1;
9272 dgst_pos2 = 2;
9273 dgst_pos3 = 3;
9274 break;
9275
9276 case 8700: hash_type = HASH_TYPE_LOTUS6;
9277 salt_type = SALT_TYPE_EMBEDDED;
9278 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9279 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9280 kern_type = KERN_TYPE_LOTUS6;
9281 dgst_size = DGST_SIZE_4_4;
9282 parse_func = lotus6_parse_hash;
9283 sort_by_digest = sort_by_digest_4_4;
9284 opti_type = OPTI_TYPE_EARLY_SKIP
9285 | OPTI_TYPE_NOT_ITERATED
9286 | OPTI_TYPE_RAW_HASH;
9287 dgst_pos0 = 0;
9288 dgst_pos1 = 1;
9289 dgst_pos2 = 2;
9290 dgst_pos3 = 3;
9291 break;
9292
9293 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9294 salt_type = SALT_TYPE_EMBEDDED;
9295 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9296 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9297 kern_type = KERN_TYPE_ANDROIDFDE;
9298 dgst_size = DGST_SIZE_4_4;
9299 parse_func = androidfde_parse_hash;
9300 sort_by_digest = sort_by_digest_4_4;
9301 opti_type = OPTI_TYPE_ZERO_BYTE;
9302 dgst_pos0 = 0;
9303 dgst_pos1 = 1;
9304 dgst_pos2 = 2;
9305 dgst_pos3 = 3;
9306 break;
9307
9308 case 8900: hash_type = HASH_TYPE_SCRYPT;
9309 salt_type = SALT_TYPE_EMBEDDED;
9310 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9311 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9312 kern_type = KERN_TYPE_SCRYPT;
9313 dgst_size = DGST_SIZE_4_8;
9314 parse_func = scrypt_parse_hash;
9315 sort_by_digest = sort_by_digest_4_8;
9316 opti_type = OPTI_TYPE_ZERO_BYTE;
9317 dgst_pos0 = 0;
9318 dgst_pos1 = 1;
9319 dgst_pos2 = 2;
9320 dgst_pos3 = 3;
9321 break;
9322
9323 case 9000: hash_type = HASH_TYPE_SHA1;
9324 salt_type = SALT_TYPE_EMBEDDED;
9325 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9326 opts_type = OPTS_TYPE_PT_GENERATE_LE
9327 | OPTS_TYPE_ST_GENERATE_LE;
9328 kern_type = KERN_TYPE_PSAFE2;
9329 dgst_size = DGST_SIZE_4_5;
9330 parse_func = psafe2_parse_hash;
9331 sort_by_digest = sort_by_digest_4_5;
9332 opti_type = OPTI_TYPE_ZERO_BYTE;
9333 dgst_pos0 = 0;
9334 dgst_pos1 = 1;
9335 dgst_pos2 = 2;
9336 dgst_pos3 = 3;
9337 break;
9338
9339 case 9100: hash_type = HASH_TYPE_LOTUS8;
9340 salt_type = SALT_TYPE_EMBEDDED;
9341 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9342 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9343 kern_type = KERN_TYPE_LOTUS8;
9344 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9345 parse_func = lotus8_parse_hash;
9346 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9347 opti_type = OPTI_TYPE_ZERO_BYTE;
9348 dgst_pos0 = 0;
9349 dgst_pos1 = 1;
9350 dgst_pos2 = 2;
9351 dgst_pos3 = 3;
9352 break;
9353
9354 case 9200: hash_type = HASH_TYPE_SHA256;
9355 salt_type = SALT_TYPE_EMBEDDED;
9356 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9357 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9358 kern_type = KERN_TYPE_PBKDF2_SHA256;
9359 dgst_size = DGST_SIZE_4_32;
9360 parse_func = cisco8_parse_hash;
9361 sort_by_digest = sort_by_digest_4_32;
9362 opti_type = OPTI_TYPE_ZERO_BYTE
9363 | OPTI_TYPE_SLOW_HASH_SIMD;
9364 dgst_pos0 = 0;
9365 dgst_pos1 = 1;
9366 dgst_pos2 = 2;
9367 dgst_pos3 = 3;
9368 break;
9369
9370 case 9300: hash_type = HASH_TYPE_SCRYPT;
9371 salt_type = SALT_TYPE_EMBEDDED;
9372 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9373 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9374 kern_type = KERN_TYPE_SCRYPT;
9375 dgst_size = DGST_SIZE_4_8;
9376 parse_func = cisco9_parse_hash;
9377 sort_by_digest = sort_by_digest_4_8;
9378 opti_type = OPTI_TYPE_ZERO_BYTE;
9379 dgst_pos0 = 0;
9380 dgst_pos1 = 1;
9381 dgst_pos2 = 2;
9382 dgst_pos3 = 3;
9383 break;
9384
9385 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9386 salt_type = SALT_TYPE_EMBEDDED;
9387 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9388 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9389 kern_type = KERN_TYPE_OFFICE2007;
9390 dgst_size = DGST_SIZE_4_4;
9391 parse_func = office2007_parse_hash;
9392 sort_by_digest = sort_by_digest_4_4;
9393 opti_type = OPTI_TYPE_ZERO_BYTE;
9394 dgst_pos0 = 0;
9395 dgst_pos1 = 1;
9396 dgst_pos2 = 2;
9397 dgst_pos3 = 3;
9398 break;
9399
9400 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9401 salt_type = SALT_TYPE_EMBEDDED;
9402 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9403 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9404 kern_type = KERN_TYPE_OFFICE2010;
9405 dgst_size = DGST_SIZE_4_4;
9406 parse_func = office2010_parse_hash;
9407 sort_by_digest = sort_by_digest_4_4;
9408 opti_type = OPTI_TYPE_ZERO_BYTE;
9409 dgst_pos0 = 0;
9410 dgst_pos1 = 1;
9411 dgst_pos2 = 2;
9412 dgst_pos3 = 3;
9413 break;
9414
9415 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9416 salt_type = SALT_TYPE_EMBEDDED;
9417 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9418 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9419 kern_type = KERN_TYPE_OFFICE2013;
9420 dgst_size = DGST_SIZE_4_4;
9421 parse_func = office2013_parse_hash;
9422 sort_by_digest = sort_by_digest_4_4;
9423 opti_type = OPTI_TYPE_ZERO_BYTE;
9424 dgst_pos0 = 0;
9425 dgst_pos1 = 1;
9426 dgst_pos2 = 2;
9427 dgst_pos3 = 3;
9428 break;
9429
9430 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9431 salt_type = SALT_TYPE_EMBEDDED;
9432 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9433 opts_type = OPTS_TYPE_PT_GENERATE_LE
9434 | OPTS_TYPE_PT_ADD80
9435 | OPTS_TYPE_PT_UNICODE;
9436 kern_type = KERN_TYPE_OLDOFFICE01;
9437 dgst_size = DGST_SIZE_4_4;
9438 parse_func = oldoffice01_parse_hash;
9439 sort_by_digest = sort_by_digest_4_4;
9440 opti_type = OPTI_TYPE_ZERO_BYTE
9441 | OPTI_TYPE_PRECOMPUTE_INIT
9442 | OPTI_TYPE_NOT_ITERATED;
9443 dgst_pos0 = 0;
9444 dgst_pos1 = 1;
9445 dgst_pos2 = 2;
9446 dgst_pos3 = 3;
9447 break;
9448
9449 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9450 salt_type = SALT_TYPE_EMBEDDED;
9451 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9452 opts_type = OPTS_TYPE_PT_GENERATE_LE
9453 | OPTS_TYPE_PT_ADD80;
9454 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9455 dgst_size = DGST_SIZE_4_4;
9456 parse_func = oldoffice01cm1_parse_hash;
9457 sort_by_digest = sort_by_digest_4_4;
9458 opti_type = OPTI_TYPE_ZERO_BYTE
9459 | OPTI_TYPE_PRECOMPUTE_INIT
9460 | OPTI_TYPE_NOT_ITERATED;
9461 dgst_pos0 = 0;
9462 dgst_pos1 = 1;
9463 dgst_pos2 = 2;
9464 dgst_pos3 = 3;
9465 break;
9466
9467 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9468 salt_type = SALT_TYPE_EMBEDDED;
9469 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9470 opts_type = OPTS_TYPE_PT_GENERATE_LE
9471 | OPTS_TYPE_PT_ADD80
9472 | OPTS_TYPE_PT_UNICODE
9473 | OPTS_TYPE_PT_NEVERCRACK;
9474 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9475 dgst_size = DGST_SIZE_4_4;
9476 parse_func = oldoffice01cm2_parse_hash;
9477 sort_by_digest = sort_by_digest_4_4;
9478 opti_type = OPTI_TYPE_ZERO_BYTE
9479 | OPTI_TYPE_PRECOMPUTE_INIT
9480 | OPTI_TYPE_NOT_ITERATED;
9481 dgst_pos0 = 0;
9482 dgst_pos1 = 1;
9483 dgst_pos2 = 2;
9484 dgst_pos3 = 3;
9485 break;
9486
9487 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9488 salt_type = SALT_TYPE_EMBEDDED;
9489 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9490 opts_type = OPTS_TYPE_PT_GENERATE_BE
9491 | OPTS_TYPE_PT_ADD80
9492 | OPTS_TYPE_PT_UNICODE;
9493 kern_type = KERN_TYPE_OLDOFFICE34;
9494 dgst_size = DGST_SIZE_4_4;
9495 parse_func = oldoffice34_parse_hash;
9496 sort_by_digest = sort_by_digest_4_4;
9497 opti_type = OPTI_TYPE_ZERO_BYTE
9498 | OPTI_TYPE_PRECOMPUTE_INIT
9499 | OPTI_TYPE_NOT_ITERATED;
9500 dgst_pos0 = 0;
9501 dgst_pos1 = 1;
9502 dgst_pos2 = 2;
9503 dgst_pos3 = 3;
9504 break;
9505
9506 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9507 salt_type = SALT_TYPE_EMBEDDED;
9508 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9509 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9510 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9511 dgst_size = DGST_SIZE_4_4;
9512 parse_func = oldoffice34cm1_parse_hash;
9513 sort_by_digest = sort_by_digest_4_4;
9514 opti_type = OPTI_TYPE_ZERO_BYTE
9515 | OPTI_TYPE_PRECOMPUTE_INIT
9516 | OPTI_TYPE_NOT_ITERATED;
9517 dgst_pos0 = 0;
9518 dgst_pos1 = 1;
9519 dgst_pos2 = 2;
9520 dgst_pos3 = 3;
9521 break;
9522
9523 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9524 salt_type = SALT_TYPE_EMBEDDED;
9525 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9526 opts_type = OPTS_TYPE_PT_GENERATE_BE
9527 | OPTS_TYPE_PT_ADD80
9528 | OPTS_TYPE_PT_UNICODE
9529 | OPTS_TYPE_PT_NEVERCRACK;
9530 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9531 dgst_size = DGST_SIZE_4_4;
9532 parse_func = oldoffice34cm2_parse_hash;
9533 sort_by_digest = sort_by_digest_4_4;
9534 opti_type = OPTI_TYPE_ZERO_BYTE
9535 | OPTI_TYPE_PRECOMPUTE_INIT
9536 | OPTI_TYPE_NOT_ITERATED;
9537 dgst_pos0 = 0;
9538 dgst_pos1 = 1;
9539 dgst_pos2 = 2;
9540 dgst_pos3 = 3;
9541 break;
9542
9543 case 9900: hash_type = HASH_TYPE_MD5;
9544 salt_type = SALT_TYPE_NONE;
9545 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9546 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9547 kern_type = KERN_TYPE_RADMIN2;
9548 dgst_size = DGST_SIZE_4_4;
9549 parse_func = radmin2_parse_hash;
9550 sort_by_digest = sort_by_digest_4_4;
9551 opti_type = OPTI_TYPE_ZERO_BYTE
9552 | OPTI_TYPE_PRECOMPUTE_INIT
9553 | OPTI_TYPE_EARLY_SKIP
9554 | OPTI_TYPE_NOT_ITERATED
9555 | OPTI_TYPE_NOT_SALTED;
9556 dgst_pos0 = 0;
9557 dgst_pos1 = 3;
9558 dgst_pos2 = 2;
9559 dgst_pos3 = 1;
9560 break;
9561
9562 case 10000: hash_type = HASH_TYPE_SHA256;
9563 salt_type = SALT_TYPE_EMBEDDED;
9564 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9565 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9566 kern_type = KERN_TYPE_PBKDF2_SHA256;
9567 dgst_size = DGST_SIZE_4_32;
9568 parse_func = djangopbkdf2_parse_hash;
9569 sort_by_digest = sort_by_digest_4_32;
9570 opti_type = OPTI_TYPE_ZERO_BYTE
9571 | OPTI_TYPE_SLOW_HASH_SIMD;
9572 dgst_pos0 = 0;
9573 dgst_pos1 = 1;
9574 dgst_pos2 = 2;
9575 dgst_pos3 = 3;
9576 break;
9577
9578 case 10100: hash_type = HASH_TYPE_SIPHASH;
9579 salt_type = SALT_TYPE_EMBEDDED;
9580 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9581 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9582 kern_type = KERN_TYPE_SIPHASH;
9583 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9584 parse_func = siphash_parse_hash;
9585 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9586 opti_type = OPTI_TYPE_ZERO_BYTE
9587 | OPTI_TYPE_NOT_ITERATED
9588 | OPTI_TYPE_RAW_HASH;
9589 dgst_pos0 = 0;
9590 dgst_pos1 = 1;
9591 dgst_pos2 = 2;
9592 dgst_pos3 = 3;
9593 break;
9594
9595 case 10200: hash_type = HASH_TYPE_MD5;
9596 salt_type = SALT_TYPE_EMBEDDED;
9597 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9598 opts_type = OPTS_TYPE_PT_GENERATE_LE
9599 | OPTS_TYPE_ST_ADD80
9600 | OPTS_TYPE_ST_ADDBITS14;
9601 kern_type = KERN_TYPE_HMACMD5_PW;
9602 dgst_size = DGST_SIZE_4_4;
9603 parse_func = crammd5_parse_hash;
9604 sort_by_digest = sort_by_digest_4_4;
9605 opti_type = OPTI_TYPE_ZERO_BYTE
9606 | OPTI_TYPE_NOT_ITERATED;
9607 dgst_pos0 = 0;
9608 dgst_pos1 = 3;
9609 dgst_pos2 = 2;
9610 dgst_pos3 = 1;
9611 break;
9612
9613 case 10300: hash_type = HASH_TYPE_SHA1;
9614 salt_type = SALT_TYPE_EMBEDDED;
9615 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9616 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9617 kern_type = KERN_TYPE_SAPH_SHA1;
9618 dgst_size = DGST_SIZE_4_5;
9619 parse_func = saph_sha1_parse_hash;
9620 sort_by_digest = sort_by_digest_4_5;
9621 opti_type = OPTI_TYPE_ZERO_BYTE;
9622 dgst_pos0 = 0;
9623 dgst_pos1 = 1;
9624 dgst_pos2 = 2;
9625 dgst_pos3 = 3;
9626 break;
9627
9628 case 10400: hash_type = HASH_TYPE_PDFU16;
9629 salt_type = SALT_TYPE_EMBEDDED;
9630 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9631 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9632 kern_type = KERN_TYPE_PDF11;
9633 dgst_size = DGST_SIZE_4_4;
9634 parse_func = pdf11_parse_hash;
9635 sort_by_digest = sort_by_digest_4_4;
9636 opti_type = OPTI_TYPE_ZERO_BYTE
9637 | OPTI_TYPE_NOT_ITERATED;
9638 dgst_pos0 = 0;
9639 dgst_pos1 = 1;
9640 dgst_pos2 = 2;
9641 dgst_pos3 = 3;
9642 break;
9643
9644 case 10410: hash_type = HASH_TYPE_PDFU16;
9645 salt_type = SALT_TYPE_EMBEDDED;
9646 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9647 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9648 kern_type = KERN_TYPE_PDF11CM1;
9649 dgst_size = DGST_SIZE_4_4;
9650 parse_func = pdf11cm1_parse_hash;
9651 sort_by_digest = sort_by_digest_4_4;
9652 opti_type = OPTI_TYPE_ZERO_BYTE
9653 | OPTI_TYPE_NOT_ITERATED;
9654 dgst_pos0 = 0;
9655 dgst_pos1 = 1;
9656 dgst_pos2 = 2;
9657 dgst_pos3 = 3;
9658 break;
9659
9660 case 10420: hash_type = HASH_TYPE_PDFU16;
9661 salt_type = SALT_TYPE_EMBEDDED;
9662 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9663 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9664 kern_type = KERN_TYPE_PDF11CM2;
9665 dgst_size = DGST_SIZE_4_4;
9666 parse_func = pdf11cm2_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 = 1;
9672 dgst_pos2 = 2;
9673 dgst_pos3 = 3;
9674 break;
9675
9676 case 10500: hash_type = HASH_TYPE_PDFU16;
9677 salt_type = SALT_TYPE_EMBEDDED;
9678 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9679 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9680 kern_type = KERN_TYPE_PDF14;
9681 dgst_size = DGST_SIZE_4_4;
9682 parse_func = pdf14_parse_hash;
9683 sort_by_digest = sort_by_digest_4_4;
9684 opti_type = OPTI_TYPE_ZERO_BYTE
9685 | OPTI_TYPE_NOT_ITERATED;
9686 dgst_pos0 = 0;
9687 dgst_pos1 = 1;
9688 dgst_pos2 = 2;
9689 dgst_pos3 = 3;
9690 break;
9691
9692 case 10600: hash_type = HASH_TYPE_SHA256;
9693 salt_type = SALT_TYPE_EMBEDDED;
9694 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9695 opts_type = OPTS_TYPE_PT_GENERATE_BE
9696 | OPTS_TYPE_ST_ADD80
9697 | OPTS_TYPE_ST_ADDBITS15
9698 | OPTS_TYPE_HASH_COPY;
9699 kern_type = KERN_TYPE_SHA256_PWSLT;
9700 dgst_size = DGST_SIZE_4_8;
9701 parse_func = pdf17l3_parse_hash;
9702 sort_by_digest = sort_by_digest_4_8;
9703 opti_type = OPTI_TYPE_ZERO_BYTE
9704 | OPTI_TYPE_PRECOMPUTE_INIT
9705 | OPTI_TYPE_PRECOMPUTE_MERKLE
9706 | OPTI_TYPE_EARLY_SKIP
9707 | OPTI_TYPE_NOT_ITERATED
9708 | OPTI_TYPE_APPENDED_SALT
9709 | OPTI_TYPE_RAW_HASH;
9710 dgst_pos0 = 3;
9711 dgst_pos1 = 7;
9712 dgst_pos2 = 2;
9713 dgst_pos3 = 6;
9714 break;
9715
9716 case 10700: hash_type = HASH_TYPE_PDFU32;
9717 salt_type = SALT_TYPE_EMBEDDED;
9718 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9719 opts_type = OPTS_TYPE_PT_GENERATE_LE
9720 | OPTS_TYPE_HASH_COPY;
9721 kern_type = KERN_TYPE_PDF17L8;
9722 dgst_size = DGST_SIZE_4_8;
9723 parse_func = pdf17l8_parse_hash;
9724 sort_by_digest = sort_by_digest_4_8;
9725 opti_type = OPTI_TYPE_ZERO_BYTE
9726 | OPTI_TYPE_NOT_ITERATED;
9727 dgst_pos0 = 0;
9728 dgst_pos1 = 1;
9729 dgst_pos2 = 2;
9730 dgst_pos3 = 3;
9731 break;
9732
9733 case 10800: hash_type = HASH_TYPE_SHA384;
9734 salt_type = SALT_TYPE_NONE;
9735 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9736 opts_type = OPTS_TYPE_PT_GENERATE_BE
9737 | OPTS_TYPE_PT_ADD80
9738 | OPTS_TYPE_PT_ADDBITS15;
9739 kern_type = KERN_TYPE_SHA384;
9740 dgst_size = DGST_SIZE_8_8;
9741 parse_func = sha384_parse_hash;
9742 sort_by_digest = sort_by_digest_8_8;
9743 opti_type = OPTI_TYPE_ZERO_BYTE
9744 | OPTI_TYPE_PRECOMPUTE_INIT
9745 | OPTI_TYPE_PRECOMPUTE_MERKLE
9746 | OPTI_TYPE_EARLY_SKIP
9747 | OPTI_TYPE_NOT_ITERATED
9748 | OPTI_TYPE_NOT_SALTED
9749 | OPTI_TYPE_USES_BITS_64
9750 | OPTI_TYPE_RAW_HASH;
9751 dgst_pos0 = 6;
9752 dgst_pos1 = 7;
9753 dgst_pos2 = 4;
9754 dgst_pos3 = 5;
9755 break;
9756
9757 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9758 salt_type = SALT_TYPE_EMBEDDED;
9759 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9760 opts_type = OPTS_TYPE_PT_GENERATE_LE
9761 | OPTS_TYPE_ST_BASE64
9762 | OPTS_TYPE_HASH_COPY;
9763 kern_type = KERN_TYPE_PBKDF2_SHA256;
9764 dgst_size = DGST_SIZE_4_32;
9765 parse_func = pbkdf2_sha256_parse_hash;
9766 sort_by_digest = sort_by_digest_4_32;
9767 opti_type = OPTI_TYPE_ZERO_BYTE
9768 | OPTI_TYPE_SLOW_HASH_SIMD;
9769 dgst_pos0 = 0;
9770 dgst_pos1 = 1;
9771 dgst_pos2 = 2;
9772 dgst_pos3 = 3;
9773 break;
9774
9775 case 11000: hash_type = HASH_TYPE_MD5;
9776 salt_type = SALT_TYPE_INTERN;
9777 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9778 opts_type = OPTS_TYPE_PT_GENERATE_LE
9779 | OPTS_TYPE_PT_ADD80;
9780 kern_type = KERN_TYPE_PRESTASHOP;
9781 dgst_size = DGST_SIZE_4_4;
9782 parse_func = prestashop_parse_hash;
9783 sort_by_digest = sort_by_digest_4_4;
9784 opti_type = OPTI_TYPE_ZERO_BYTE
9785 | OPTI_TYPE_PRECOMPUTE_INIT
9786 | OPTI_TYPE_NOT_ITERATED
9787 | OPTI_TYPE_PREPENDED_SALT;
9788 dgst_pos0 = 0;
9789 dgst_pos1 = 3;
9790 dgst_pos2 = 2;
9791 dgst_pos3 = 1;
9792 break;
9793
9794 case 11100: hash_type = HASH_TYPE_MD5;
9795 salt_type = SALT_TYPE_EMBEDDED;
9796 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9797 opts_type = OPTS_TYPE_PT_GENERATE_LE
9798 | OPTS_TYPE_ST_ADD80;
9799 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9800 dgst_size = DGST_SIZE_4_4;
9801 parse_func = postgresql_auth_parse_hash;
9802 sort_by_digest = sort_by_digest_4_4;
9803 opti_type = OPTI_TYPE_ZERO_BYTE
9804 | OPTI_TYPE_PRECOMPUTE_INIT
9805 | OPTI_TYPE_PRECOMPUTE_MERKLE
9806 | OPTI_TYPE_EARLY_SKIP;
9807 dgst_pos0 = 0;
9808 dgst_pos1 = 3;
9809 dgst_pos2 = 2;
9810 dgst_pos3 = 1;
9811 break;
9812
9813 case 11200: hash_type = HASH_TYPE_SHA1;
9814 salt_type = SALT_TYPE_EMBEDDED;
9815 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9816 opts_type = OPTS_TYPE_PT_GENERATE_BE
9817 | OPTS_TYPE_PT_ADD80
9818 | OPTS_TYPE_ST_HEX;
9819 kern_type = KERN_TYPE_MYSQL_AUTH;
9820 dgst_size = DGST_SIZE_4_5;
9821 parse_func = mysql_auth_parse_hash;
9822 sort_by_digest = sort_by_digest_4_5;
9823 opti_type = OPTI_TYPE_ZERO_BYTE
9824 | OPTI_TYPE_EARLY_SKIP;
9825 dgst_pos0 = 3;
9826 dgst_pos1 = 4;
9827 dgst_pos2 = 2;
9828 dgst_pos3 = 1;
9829 break;
9830
9831 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9832 salt_type = SALT_TYPE_EMBEDDED;
9833 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9834 opts_type = OPTS_TYPE_PT_GENERATE_LE
9835 | OPTS_TYPE_ST_HEX
9836 | OPTS_TYPE_ST_ADD80;
9837 kern_type = KERN_TYPE_BITCOIN_WALLET;
9838 dgst_size = DGST_SIZE_4_4;
9839 parse_func = bitcoin_wallet_parse_hash;
9840 sort_by_digest = sort_by_digest_4_4;
9841 opti_type = OPTI_TYPE_ZERO_BYTE;
9842 dgst_pos0 = 0;
9843 dgst_pos1 = 1;
9844 dgst_pos2 = 2;
9845 dgst_pos3 = 3;
9846 break;
9847
9848 case 11400: hash_type = HASH_TYPE_MD5;
9849 salt_type = SALT_TYPE_EMBEDDED;
9850 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9851 opts_type = OPTS_TYPE_PT_GENERATE_LE
9852 | OPTS_TYPE_PT_ADD80
9853 | OPTS_TYPE_HASH_COPY;
9854 kern_type = KERN_TYPE_SIP_AUTH;
9855 dgst_size = DGST_SIZE_4_4;
9856 parse_func = sip_auth_parse_hash;
9857 sort_by_digest = sort_by_digest_4_4;
9858 opti_type = OPTI_TYPE_ZERO_BYTE;
9859 dgst_pos0 = 0;
9860 dgst_pos1 = 3;
9861 dgst_pos2 = 2;
9862 dgst_pos3 = 1;
9863 break;
9864
9865 case 11500: hash_type = HASH_TYPE_CRC32;
9866 salt_type = SALT_TYPE_INTERN;
9867 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9868 opts_type = OPTS_TYPE_PT_GENERATE_LE
9869 | OPTS_TYPE_ST_GENERATE_LE
9870 | OPTS_TYPE_ST_HEX;
9871 kern_type = KERN_TYPE_CRC32;
9872 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9873 parse_func = crc32_parse_hash;
9874 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9875 opti_type = OPTI_TYPE_ZERO_BYTE;
9876 dgst_pos0 = 0;
9877 dgst_pos1 = 1;
9878 dgst_pos2 = 2;
9879 dgst_pos3 = 3;
9880 break;
9881
9882 case 11600: hash_type = HASH_TYPE_AES;
9883 salt_type = SALT_TYPE_EMBEDDED;
9884 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9885 opts_type = OPTS_TYPE_PT_GENERATE_LE
9886 | OPTS_TYPE_PT_NEVERCRACK;
9887 kern_type = KERN_TYPE_SEVEN_ZIP;
9888 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9889 parse_func = seven_zip_parse_hash;
9890 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9891 opti_type = OPTI_TYPE_ZERO_BYTE;
9892 dgst_pos0 = 0;
9893 dgst_pos1 = 1;
9894 dgst_pos2 = 2;
9895 dgst_pos3 = 3;
9896 break;
9897
9898 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9899 salt_type = SALT_TYPE_NONE;
9900 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9901 opts_type = OPTS_TYPE_PT_GENERATE_LE
9902 | OPTS_TYPE_PT_ADD01;
9903 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9904 dgst_size = DGST_SIZE_4_8;
9905 parse_func = gost2012sbog_256_parse_hash;
9906 sort_by_digest = sort_by_digest_4_8;
9907 opti_type = OPTI_TYPE_ZERO_BYTE;
9908 dgst_pos0 = 0;
9909 dgst_pos1 = 1;
9910 dgst_pos2 = 2;
9911 dgst_pos3 = 3;
9912 break;
9913
9914 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
9915 salt_type = SALT_TYPE_NONE;
9916 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9917 opts_type = OPTS_TYPE_PT_GENERATE_LE
9918 | OPTS_TYPE_PT_ADD01;
9919 kern_type = KERN_TYPE_GOST_2012SBOG_512;
9920 dgst_size = DGST_SIZE_4_16;
9921 parse_func = gost2012sbog_512_parse_hash;
9922 sort_by_digest = sort_by_digest_4_16;
9923 opti_type = OPTI_TYPE_ZERO_BYTE;
9924 dgst_pos0 = 0;
9925 dgst_pos1 = 1;
9926 dgst_pos2 = 2;
9927 dgst_pos3 = 3;
9928 break;
9929
9930 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
9931 salt_type = SALT_TYPE_EMBEDDED;
9932 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9933 opts_type = OPTS_TYPE_PT_GENERATE_LE
9934 | OPTS_TYPE_ST_BASE64
9935 | OPTS_TYPE_HASH_COPY;
9936 kern_type = KERN_TYPE_PBKDF2_MD5;
9937 dgst_size = DGST_SIZE_4_32;
9938 parse_func = pbkdf2_md5_parse_hash;
9939 sort_by_digest = sort_by_digest_4_32;
9940 opti_type = OPTI_TYPE_ZERO_BYTE
9941 | OPTI_TYPE_SLOW_HASH_SIMD;
9942 dgst_pos0 = 0;
9943 dgst_pos1 = 1;
9944 dgst_pos2 = 2;
9945 dgst_pos3 = 3;
9946 break;
9947
9948 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
9949 salt_type = SALT_TYPE_EMBEDDED;
9950 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9951 opts_type = OPTS_TYPE_PT_GENERATE_LE
9952 | OPTS_TYPE_ST_BASE64
9953 | OPTS_TYPE_HASH_COPY;
9954 kern_type = KERN_TYPE_PBKDF2_SHA1;
9955 dgst_size = DGST_SIZE_4_32;
9956 parse_func = pbkdf2_sha1_parse_hash;
9957 sort_by_digest = sort_by_digest_4_32;
9958 opti_type = OPTI_TYPE_ZERO_BYTE
9959 | OPTI_TYPE_SLOW_HASH_SIMD;
9960 dgst_pos0 = 0;
9961 dgst_pos1 = 1;
9962 dgst_pos2 = 2;
9963 dgst_pos3 = 3;
9964 break;
9965
9966 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
9967 salt_type = SALT_TYPE_EMBEDDED;
9968 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9969 opts_type = OPTS_TYPE_PT_GENERATE_LE
9970 | OPTS_TYPE_ST_BASE64
9971 | OPTS_TYPE_HASH_COPY;
9972 kern_type = KERN_TYPE_PBKDF2_SHA512;
9973 dgst_size = DGST_SIZE_8_16;
9974 parse_func = pbkdf2_sha512_parse_hash;
9975 sort_by_digest = sort_by_digest_8_16;
9976 opti_type = OPTI_TYPE_ZERO_BYTE
9977 | OPTI_TYPE_USES_BITS_64
9978 | OPTI_TYPE_SLOW_HASH_SIMD;
9979 dgst_pos0 = 0;
9980 dgst_pos1 = 1;
9981 dgst_pos2 = 2;
9982 dgst_pos3 = 3;
9983 break;
9984
9985 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
9986 salt_type = SALT_TYPE_EMBEDDED;
9987 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9988 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9989 kern_type = KERN_TYPE_ECRYPTFS;
9990 dgst_size = DGST_SIZE_8_8;
9991 parse_func = ecryptfs_parse_hash;
9992 sort_by_digest = sort_by_digest_8_8;
9993 opti_type = OPTI_TYPE_ZERO_BYTE
9994 | OPTI_TYPE_USES_BITS_64;
9995 dgst_pos0 = 0;
9996 dgst_pos1 = 1;
9997 dgst_pos2 = 2;
9998 dgst_pos3 = 3;
9999 break;
10000
10001 case 12300: hash_type = HASH_TYPE_ORACLET;
10002 salt_type = SALT_TYPE_EMBEDDED;
10003 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10004 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10005 kern_type = KERN_TYPE_ORACLET;
10006 dgst_size = DGST_SIZE_8_16;
10007 parse_func = oraclet_parse_hash;
10008 sort_by_digest = sort_by_digest_8_16;
10009 opti_type = OPTI_TYPE_ZERO_BYTE
10010 | OPTI_TYPE_USES_BITS_64;
10011 dgst_pos0 = 0;
10012 dgst_pos1 = 1;
10013 dgst_pos2 = 2;
10014 dgst_pos3 = 3;
10015 break;
10016
10017 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10018 salt_type = SALT_TYPE_EMBEDDED;
10019 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10020 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10021 kern_type = KERN_TYPE_BSDICRYPT;
10022 dgst_size = DGST_SIZE_4_4;
10023 parse_func = bsdicrypt_parse_hash;
10024 sort_by_digest = sort_by_digest_4_4;
10025 opti_type = OPTI_TYPE_ZERO_BYTE
10026 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10027 dgst_pos0 = 0;
10028 dgst_pos1 = 1;
10029 dgst_pos2 = 2;
10030 dgst_pos3 = 3;
10031 break;
10032
10033 case 12500: hash_type = HASH_TYPE_RAR3HP;
10034 salt_type = SALT_TYPE_EMBEDDED;
10035 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10036 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10037 kern_type = KERN_TYPE_RAR3;
10038 dgst_size = DGST_SIZE_4_4;
10039 parse_func = rar3hp_parse_hash;
10040 sort_by_digest = sort_by_digest_4_4;
10041 opti_type = OPTI_TYPE_ZERO_BYTE;
10042 dgst_pos0 = 0;
10043 dgst_pos1 = 1;
10044 dgst_pos2 = 2;
10045 dgst_pos3 = 3;
10046 break;
10047
10048 case 12600: hash_type = HASH_TYPE_SHA256;
10049 salt_type = SALT_TYPE_INTERN;
10050 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10051 opts_type = OPTS_TYPE_PT_GENERATE_BE
10052 | OPTS_TYPE_PT_ADD80;
10053 kern_type = KERN_TYPE_CF10;
10054 dgst_size = DGST_SIZE_4_8;
10055 parse_func = cf10_parse_hash;
10056 sort_by_digest = sort_by_digest_4_8;
10057 opti_type = OPTI_TYPE_ZERO_BYTE
10058 | OPTI_TYPE_PRECOMPUTE_INIT
10059 | OPTI_TYPE_EARLY_SKIP
10060 | OPTI_TYPE_NOT_ITERATED;
10061 dgst_pos0 = 3;
10062 dgst_pos1 = 7;
10063 dgst_pos2 = 2;
10064 dgst_pos3 = 6;
10065 break;
10066
10067 case 12700: hash_type = HASH_TYPE_AES;
10068 salt_type = SALT_TYPE_EMBEDDED;
10069 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10070 opts_type = OPTS_TYPE_PT_GENERATE_LE
10071 | OPTS_TYPE_HASH_COPY;
10072 kern_type = KERN_TYPE_MYWALLET;
10073 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10074 parse_func = mywallet_parse_hash;
10075 sort_by_digest = sort_by_digest_4_5;
10076 opti_type = OPTI_TYPE_ZERO_BYTE;
10077 dgst_pos0 = 0;
10078 dgst_pos1 = 1;
10079 dgst_pos2 = 2;
10080 dgst_pos3 = 3;
10081 break;
10082
10083 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10084 salt_type = SALT_TYPE_EMBEDDED;
10085 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10086 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10087 kern_type = KERN_TYPE_MS_DRSR;
10088 dgst_size = DGST_SIZE_4_8;
10089 parse_func = ms_drsr_parse_hash;
10090 sort_by_digest = sort_by_digest_4_8;
10091 opti_type = OPTI_TYPE_ZERO_BYTE;
10092 dgst_pos0 = 0;
10093 dgst_pos1 = 1;
10094 dgst_pos2 = 2;
10095 dgst_pos3 = 3;
10096 break;
10097
10098 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10099 salt_type = SALT_TYPE_EMBEDDED;
10100 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10101 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10102 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10103 dgst_size = DGST_SIZE_4_8;
10104 parse_func = androidfde_samsung_parse_hash;
10105 sort_by_digest = sort_by_digest_4_8;
10106 opti_type = OPTI_TYPE_ZERO_BYTE;
10107 dgst_pos0 = 0;
10108 dgst_pos1 = 1;
10109 dgst_pos2 = 2;
10110 dgst_pos3 = 3;
10111 break;
10112
10113 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10114 salt_type = SALT_TYPE_EMBEDDED;
10115 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10116 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10117 kern_type = KERN_TYPE_RAR5;
10118 dgst_size = DGST_SIZE_4_4;
10119 parse_func = rar5_parse_hash;
10120 sort_by_digest = sort_by_digest_4_4;
10121 opti_type = OPTI_TYPE_ZERO_BYTE;
10122 dgst_pos0 = 0;
10123 dgst_pos1 = 1;
10124 dgst_pos2 = 2;
10125 dgst_pos3 = 3;
10126 break;
10127
10128 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10129 salt_type = SALT_TYPE_EMBEDDED;
10130 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10131 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10132 kern_type = KERN_TYPE_KRB5TGS;
10133 dgst_size = DGST_SIZE_4_4;
10134 parse_func = krb5tgs_parse_hash;
10135 sort_by_digest = sort_by_digest_4_4;
10136 opti_type = OPTI_TYPE_ZERO_BYTE
10137 | OPTI_TYPE_NOT_ITERATED;
10138 dgst_pos0 = 0;
10139 dgst_pos1 = 1;
10140 dgst_pos2 = 2;
10141 dgst_pos3 = 3;
10142 break;
10143
10144 case 13200: hash_type = HASH_TYPE_AES;
10145 salt_type = SALT_TYPE_EMBEDDED;
10146 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10147 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10148 kern_type = KERN_TYPE_AXCRYPT;
10149 dgst_size = DGST_SIZE_4_4;
10150 parse_func = axcrypt_parse_hash;
10151 sort_by_digest = sort_by_digest_4_4;
10152 opti_type = OPTI_TYPE_ZERO_BYTE;
10153 dgst_pos0 = 0;
10154 dgst_pos1 = 1;
10155 dgst_pos2 = 2;
10156 dgst_pos3 = 3;
10157 break;
10158
10159 case 13300: hash_type = HASH_TYPE_SHA1;
10160 salt_type = SALT_TYPE_NONE;
10161 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10162 opts_type = OPTS_TYPE_PT_GENERATE_BE
10163 | OPTS_TYPE_PT_ADD80
10164 | OPTS_TYPE_PT_ADDBITS15;
10165 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10166 dgst_size = DGST_SIZE_4_5;
10167 parse_func = sha1axcrypt_parse_hash;
10168 sort_by_digest = sort_by_digest_4_5;
10169 opti_type = OPTI_TYPE_ZERO_BYTE
10170 | OPTI_TYPE_PRECOMPUTE_INIT
10171 | OPTI_TYPE_EARLY_SKIP
10172 | OPTI_TYPE_NOT_ITERATED
10173 | OPTI_TYPE_NOT_SALTED;
10174 dgst_pos0 = 0;
10175 dgst_pos1 = 4;
10176 dgst_pos2 = 3;
10177 dgst_pos3 = 2;
10178 break;
10179
10180 case 13400: hash_type = HASH_TYPE_AES;
10181 salt_type = SALT_TYPE_EMBEDDED;
10182 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10183 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10184 kern_type = KERN_TYPE_KEEPASS;
10185 dgst_size = DGST_SIZE_4_4;
10186 parse_func = keepass_parse_hash;
10187 sort_by_digest = sort_by_digest_4_4;
10188 opti_type = OPTI_TYPE_ZERO_BYTE;
10189 dgst_pos0 = 0;
10190 dgst_pos1 = 1;
10191 dgst_pos2 = 2;
10192 dgst_pos3 = 3;
10193 break;
10194
10195 case 13500: hash_type = HASH_TYPE_SHA1;
10196 salt_type = SALT_TYPE_EMBEDDED;
10197 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10198 opts_type = OPTS_TYPE_PT_GENERATE_BE
10199 | OPTS_TYPE_PT_UNICODE
10200 | OPTS_TYPE_PT_ADD80;
10201 kern_type = KERN_TYPE_PSTOKEN;
10202 dgst_size = DGST_SIZE_4_5;
10203 parse_func = pstoken_parse_hash;
10204 sort_by_digest = sort_by_digest_4_5;
10205 opti_type = OPTI_TYPE_ZERO_BYTE
10206 | OPTI_TYPE_PRECOMPUTE_INIT
10207 | OPTI_TYPE_EARLY_SKIP
10208 | OPTI_TYPE_NOT_ITERATED
10209 | OPTI_TYPE_PREPENDED_SALT
10210 | OPTI_TYPE_RAW_HASH;
10211 dgst_pos0 = 3;
10212 dgst_pos1 = 4;
10213 dgst_pos2 = 2;
10214 dgst_pos3 = 1;
10215 break;
10216
10217 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
10218 salt_type = SALT_TYPE_EMBEDDED;
10219 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10220 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10221 kern_type = KERN_TYPE_ZIP2;
10222 dgst_size = DGST_SIZE_4_4;
10223 parse_func = zip2_parse_hash;
10224 sort_by_digest = sort_by_digest_4_4;
10225 opti_type = OPTI_TYPE_ZERO_BYTE;
10226 dgst_pos0 = 0;
10227 dgst_pos1 = 1;
10228 dgst_pos2 = 2;
10229 dgst_pos3 = 3;
10230 break;
10231
10232 default: usage_mini_print (PROGNAME); return (-1);
10233 }
10234
10235 /**
10236 * parser
10237 */
10238
10239 data.parse_func = parse_func;
10240
10241 /**
10242 * misc stuff
10243 */
10244
10245 if (hex_salt)
10246 {
10247 if (salt_type == SALT_TYPE_INTERN)
10248 {
10249 opts_type |= OPTS_TYPE_ST_HEX;
10250 }
10251 else
10252 {
10253 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10254
10255 return (-1);
10256 }
10257 }
10258
10259 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10260 | (salt_type == SALT_TYPE_EXTERN)
10261 | (salt_type == SALT_TYPE_EMBEDDED)
10262 | (salt_type == SALT_TYPE_VIRTUAL));
10263
10264 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10265
10266 data.hash_type = hash_type;
10267 data.attack_mode = attack_mode;
10268 data.attack_kern = attack_kern;
10269 data.attack_exec = attack_exec;
10270 data.kern_type = kern_type;
10271 data.opts_type = opts_type;
10272 data.dgst_size = dgst_size;
10273 data.salt_type = salt_type;
10274 data.isSalted = isSalted;
10275 data.sort_by_digest = sort_by_digest;
10276 data.dgst_pos0 = dgst_pos0;
10277 data.dgst_pos1 = dgst_pos1;
10278 data.dgst_pos2 = dgst_pos2;
10279 data.dgst_pos3 = dgst_pos3;
10280
10281 esalt_size = 0;
10282
10283 switch (hash_mode)
10284 {
10285 case 2500: esalt_size = sizeof (wpa_t); break;
10286 case 5300: esalt_size = sizeof (ikepsk_t); break;
10287 case 5400: esalt_size = sizeof (ikepsk_t); break;
10288 case 5500: esalt_size = sizeof (netntlm_t); break;
10289 case 5600: esalt_size = sizeof (netntlm_t); break;
10290 case 6211: esalt_size = sizeof (tc_t); break;
10291 case 6212: esalt_size = sizeof (tc_t); break;
10292 case 6213: esalt_size = sizeof (tc_t); break;
10293 case 6221: esalt_size = sizeof (tc_t); break;
10294 case 6222: esalt_size = sizeof (tc_t); break;
10295 case 6223: esalt_size = sizeof (tc_t); break;
10296 case 6231: esalt_size = sizeof (tc_t); break;
10297 case 6232: esalt_size = sizeof (tc_t); break;
10298 case 6233: esalt_size = sizeof (tc_t); break;
10299 case 6241: esalt_size = sizeof (tc_t); break;
10300 case 6242: esalt_size = sizeof (tc_t); break;
10301 case 6243: esalt_size = sizeof (tc_t); break;
10302 case 6600: esalt_size = sizeof (agilekey_t); break;
10303 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10304 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10305 case 7300: esalt_size = sizeof (rakp_t); break;
10306 case 7500: esalt_size = sizeof (krb5pa_t); break;
10307 case 8200: esalt_size = sizeof (cloudkey_t); break;
10308 case 8800: esalt_size = sizeof (androidfde_t); break;
10309 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10310 case 9400: esalt_size = sizeof (office2007_t); break;
10311 case 9500: esalt_size = sizeof (office2010_t); break;
10312 case 9600: esalt_size = sizeof (office2013_t); break;
10313 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10314 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10315 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10316 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10317 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10318 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10319 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10320 case 10200: esalt_size = sizeof (cram_md5_t); break;
10321 case 10400: esalt_size = sizeof (pdf_t); break;
10322 case 10410: esalt_size = sizeof (pdf_t); break;
10323 case 10420: esalt_size = sizeof (pdf_t); break;
10324 case 10500: esalt_size = sizeof (pdf_t); break;
10325 case 10600: esalt_size = sizeof (pdf_t); break;
10326 case 10700: esalt_size = sizeof (pdf_t); break;
10327 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10328 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10329 case 11400: esalt_size = sizeof (sip_t); break;
10330 case 11600: esalt_size = sizeof (seven_zip_t); break;
10331 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10332 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10333 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10334 case 13000: esalt_size = sizeof (rar5_t); break;
10335 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10336 case 13400: esalt_size = sizeof (keepass_t); break;
10337 case 13500: esalt_size = sizeof (pstoken_t); break;
10338 case 13600: esalt_size = sizeof (zip2_t); break;
10339 }
10340
10341 data.esalt_size = esalt_size;
10342
10343 /**
10344 * choose dictionary parser
10345 */
10346
10347 if (hash_type == HASH_TYPE_LM)
10348 {
10349 get_next_word_func = get_next_word_lm;
10350 }
10351 else if (opts_type & OPTS_TYPE_PT_UPPER)
10352 {
10353 get_next_word_func = get_next_word_uc;
10354 }
10355 else
10356 {
10357 get_next_word_func = get_next_word_std;
10358 }
10359
10360 /**
10361 * dictstat
10362 */
10363
10364 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10365
10366 #ifdef _POSIX
10367 size_t dictstat_nmemb = 0;
10368 #endif
10369
10370 #ifdef _WIN
10371 uint dictstat_nmemb = 0;
10372 #endif
10373
10374 char dictstat[256] = { 0 };
10375
10376 FILE *dictstat_fp = NULL;
10377
10378 if (keyspace == 0)
10379 {
10380 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
10381
10382 dictstat_fp = fopen (dictstat, "rb");
10383
10384 if (dictstat_fp)
10385 {
10386 #ifdef _POSIX
10387 struct stat tmpstat;
10388
10389 fstat (fileno (dictstat_fp), &tmpstat);
10390 #endif
10391
10392 #ifdef _WIN
10393 struct stat64 tmpstat;
10394
10395 _fstat64 (fileno (dictstat_fp), &tmpstat);
10396 #endif
10397
10398 if (tmpstat.st_mtime < COMPTIME)
10399 {
10400 /* with v0.15 the format changed so we have to ensure user is using a good version
10401 since there is no version-header in the dictstat file */
10402
10403 fclose (dictstat_fp);
10404
10405 unlink (dictstat);
10406 }
10407 else
10408 {
10409 while (!feof (dictstat_fp))
10410 {
10411 dictstat_t d;
10412
10413 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10414
10415 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10416
10417 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10418 {
10419 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10420
10421 return -1;
10422 }
10423 }
10424
10425 fclose (dictstat_fp);
10426 }
10427 }
10428 }
10429
10430 /**
10431 * potfile
10432 */
10433
10434 char potfile[256] = { 0 };
10435
10436 if (potfile_path == NULL)
10437 {
10438 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
10439 }
10440 else
10441 {
10442 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
10443 }
10444
10445 data.pot_fp = NULL;
10446
10447 FILE *out_fp = NULL;
10448 FILE *pot_fp = NULL;
10449
10450 if (show == 1 || left == 1)
10451 {
10452 pot_fp = fopen (potfile, "rb");
10453
10454 if (pot_fp == NULL)
10455 {
10456 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10457
10458 return (-1);
10459 }
10460
10461 if (outfile != NULL)
10462 {
10463 if ((out_fp = fopen (outfile, "ab")) == NULL)
10464 {
10465 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10466
10467 fclose (pot_fp);
10468
10469 return (-1);
10470 }
10471 }
10472 else
10473 {
10474 out_fp = stdout;
10475 }
10476 }
10477 else
10478 {
10479 if (potfile_disable == 0)
10480 {
10481 pot_fp = fopen (potfile, "ab");
10482
10483 if (pot_fp == NULL)
10484 {
10485 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10486
10487 return (-1);
10488 }
10489
10490 data.pot_fp = pot_fp;
10491 }
10492 }
10493
10494 pot_t *pot = NULL;
10495
10496 uint pot_cnt = 0;
10497 uint pot_avail = 0;
10498
10499 if (show == 1 || left == 1)
10500 {
10501 SUPPRESS_OUTPUT = 1;
10502
10503 pot_avail = count_lines (pot_fp);
10504
10505 rewind (pot_fp);
10506
10507 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10508
10509 uint pot_hashes_avail = 0;
10510
10511 uint line_num = 0;
10512
10513 char *line_buf = (char *) mymalloc (HCBUFSIZ);
10514
10515 while (!feof (pot_fp))
10516 {
10517 line_num++;
10518
10519 int line_len = fgetl (pot_fp, line_buf);
10520
10521 if (line_len == 0) continue;
10522
10523 char *plain_buf = line_buf + line_len;
10524
10525 pot_t *pot_ptr = &pot[pot_cnt];
10526
10527 hash_t *hashes_buf = &pot_ptr->hash;
10528
10529 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10530 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10531
10532 if (pot_cnt == pot_hashes_avail)
10533 {
10534 uint pos = 0;
10535
10536 for (pos = 0; pos < INCR_POT; pos++)
10537 {
10538 if ((pot_cnt + pos) >= pot_avail) break;
10539
10540 pot_t *tmp_pot = &pot[pot_cnt + pos];
10541
10542 hash_t *tmp_hash = &tmp_pot->hash;
10543
10544 tmp_hash->digest = mymalloc (dgst_size);
10545
10546 if (isSalted)
10547 {
10548 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10549 }
10550
10551 if (esalt_size)
10552 {
10553 tmp_hash->esalt = mymalloc (esalt_size);
10554 }
10555
10556 pot_hashes_avail++;
10557 }
10558 }
10559
10560 int plain_len = 0;
10561
10562 int parser_status;
10563
10564 int iter = MAX_CUT_TRIES;
10565
10566 do
10567 {
10568 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10569 {
10570 if (line_buf[i] == ':')
10571 {
10572 line_len--;
10573
10574 break;
10575 }
10576 }
10577
10578 if (data.hash_mode != 2500)
10579 {
10580 parser_status = parse_func (line_buf, line_len, hashes_buf);
10581 }
10582 else
10583 {
10584 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10585
10586 if (line_len > max_salt_size)
10587 {
10588 parser_status = PARSER_GLOBAL_LENGTH;
10589 }
10590 else
10591 {
10592 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10593
10594 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10595
10596 hashes_buf->salt->salt_len = line_len;
10597
10598 parser_status = PARSER_OK;
10599 }
10600 }
10601
10602 // if NOT parsed without error, we add the ":" to the plain
10603
10604 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10605 {
10606 plain_len++;
10607 plain_buf--;
10608 }
10609
10610 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10611
10612 if (parser_status < PARSER_GLOBAL_ZERO)
10613 {
10614 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10615
10616 continue;
10617 }
10618
10619 if (plain_len >= 255) continue;
10620
10621 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10622
10623 pot_ptr->plain_len = plain_len;
10624
10625 pot_cnt++;
10626 }
10627
10628 myfree (line_buf);
10629
10630 fclose (pot_fp);
10631
10632 SUPPRESS_OUTPUT = 0;
10633
10634 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10635 }
10636
10637 /**
10638 * word len
10639 */
10640
10641 uint pw_min = PW_MIN;
10642 uint pw_max = PW_MAX;
10643
10644 switch (hash_mode)
10645 {
10646 case 125: if (pw_max > 32) pw_max = 32;
10647 break;
10648 case 400: if (pw_max > 40) pw_max = 40;
10649 break;
10650 case 500: if (pw_max > 16) pw_max = 16;
10651 break;
10652 case 1500: if (pw_max > 8) pw_max = 8;
10653 break;
10654 case 1600: if (pw_max > 16) pw_max = 16;
10655 break;
10656 case 1800: if (pw_max > 16) pw_max = 16;
10657 break;
10658 case 2100: if (pw_max > 16) pw_max = 16;
10659 break;
10660 case 2500: if (pw_min < 8) pw_min = 8;
10661 break;
10662 case 3000: if (pw_max > 7) pw_max = 7;
10663 break;
10664 case 5200: if (pw_max > 24) pw_max = 24;
10665 break;
10666 case 5800: if (pw_max > 16) pw_max = 16;
10667 break;
10668 case 6300: if (pw_max > 16) pw_max = 16;
10669 break;
10670 case 7400: if (pw_max > 16) pw_max = 16;
10671 break;
10672 case 7900: if (pw_max > 48) pw_max = 48;
10673 break;
10674 case 8500: if (pw_max > 8) pw_max = 8;
10675 break;
10676 case 8600: if (pw_max > 16) pw_max = 16;
10677 break;
10678 case 9710: pw_min = 5;
10679 pw_max = 5;
10680 break;
10681 case 9810: pw_min = 5;
10682 pw_max = 5;
10683 break;
10684 case 10410: pw_min = 5;
10685 pw_max = 5;
10686 break;
10687 case 10300: if (pw_max < 3) pw_min = 3;
10688 if (pw_max > 40) pw_max = 40;
10689 break;
10690 case 10500: if (pw_max < 3) pw_min = 3;
10691 if (pw_max > 40) pw_max = 40;
10692 break;
10693 case 10700: if (pw_max > 16) pw_max = 16;
10694 break;
10695 case 11300: if (pw_max > 40) pw_max = 40;
10696 break;
10697 case 11600: if (pw_max > 32) pw_max = 32;
10698 break;
10699 case 12500: if (pw_max > 20) pw_max = 20;
10700 break;
10701 case 12800: if (pw_max > 24) pw_max = 24;
10702 break;
10703 }
10704
10705 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10706 {
10707 switch (attack_kern)
10708 {
10709 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10710 break;
10711 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10712 break;
10713 }
10714 }
10715
10716 /**
10717 * charsets : keep them together for more easy maintainnce
10718 */
10719
10720 cs_t mp_sys[6] = { { { 0 }, 0 } };
10721 cs_t mp_usr[4] = { { { 0 }, 0 } };
10722
10723 mp_setup_sys (mp_sys);
10724
10725 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10726 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10727 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10728 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10729
10730 /**
10731 * load hashes, part I: find input mode, count hashes
10732 */
10733
10734 uint hashlist_mode = 0;
10735 uint hashlist_format = HLFMT_HASHCAT;
10736
10737 uint hashes_avail = 0;
10738
10739 if (benchmark == 0)
10740 {
10741 struct stat f;
10742
10743 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10744
10745 if ((hash_mode == 2500) ||
10746 (hash_mode == 5200) ||
10747 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10748 (hash_mode == 9000))
10749 {
10750 hashlist_mode = HL_MODE_ARG;
10751
10752 char *hashfile = myargv[optind];
10753
10754 data.hashfile = hashfile;
10755
10756 logfile_top_var_string ("target", hashfile);
10757 }
10758
10759 if (hashlist_mode == HL_MODE_ARG)
10760 {
10761 if (hash_mode == 2500)
10762 {
10763 struct stat st;
10764
10765 if (stat (data.hashfile, &st) == -1)
10766 {
10767 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10768
10769 return (-1);
10770 }
10771
10772 hashes_avail = st.st_size / sizeof (hccap_t);
10773 }
10774 else
10775 {
10776 hashes_avail = 1;
10777 }
10778 }
10779 else if (hashlist_mode == HL_MODE_FILE)
10780 {
10781 char *hashfile = myargv[optind];
10782
10783 data.hashfile = hashfile;
10784
10785 logfile_top_var_string ("target", hashfile);
10786
10787 FILE *fp = NULL;
10788
10789 if ((fp = fopen (hashfile, "rb")) == NULL)
10790 {
10791 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10792
10793 return (-1);
10794 }
10795
10796 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10797
10798 hashes_avail = count_lines (fp);
10799
10800 rewind (fp);
10801
10802 if (hashes_avail == 0)
10803 {
10804 log_error ("ERROR: hashfile is empty or corrupt");
10805
10806 fclose (fp);
10807
10808 return (-1);
10809 }
10810
10811 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10812
10813 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10814 {
10815 log_error ("ERROR: remove not supported in native hashfile-format mode");
10816
10817 fclose (fp);
10818
10819 return (-1);
10820 }
10821
10822 fclose (fp);
10823 }
10824 }
10825 else
10826 {
10827 hashlist_mode = HL_MODE_ARG;
10828
10829 hashes_avail = 1;
10830 }
10831
10832 if (hash_mode == 3000) hashes_avail *= 2;
10833
10834 data.hashlist_mode = hashlist_mode;
10835 data.hashlist_format = hashlist_format;
10836
10837 logfile_top_uint (hashlist_mode);
10838 logfile_top_uint (hashlist_format);
10839
10840 /**
10841 * load hashes, part II: allocate required memory, set pointers
10842 */
10843
10844 hash_t *hashes_buf = NULL;
10845 void *digests_buf = NULL;
10846 salt_t *salts_buf = NULL;
10847 void *esalts_buf = NULL;
10848
10849 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10850
10851 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10852
10853 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10854 {
10855 u32 hash_pos;
10856
10857 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10858 {
10859 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10860
10861 hashes_buf[hash_pos].hash_info = hash_info;
10862
10863 if (username && (remove || show || left))
10864 {
10865 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10866 }
10867
10868 if (benchmark)
10869 {
10870 hash_info->orighash = (char *) mymalloc (256);
10871 }
10872 }
10873 }
10874
10875 if (isSalted)
10876 {
10877 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10878
10879 if (esalt_size)
10880 {
10881 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10882 }
10883 }
10884 else
10885 {
10886 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10887 }
10888
10889 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10890 {
10891 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10892
10893 if (isSalted)
10894 {
10895 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10896
10897 if (esalt_size)
10898 {
10899 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10900 }
10901 }
10902 else
10903 {
10904 hashes_buf[hash_pos].salt = &salts_buf[0];
10905 }
10906 }
10907
10908 /**
10909 * load hashes, part III: parse hashes or generate them if benchmark
10910 */
10911
10912 uint hashes_cnt = 0;
10913
10914 if (benchmark == 0)
10915 {
10916 if (keyspace == 1)
10917 {
10918 // useless to read hash file for keyspace, cheat a little bit w/ optind
10919 }
10920 else if (hashes_avail == 0)
10921 {
10922 }
10923 else if (hashlist_mode == HL_MODE_ARG)
10924 {
10925 char *input_buf = myargv[optind];
10926
10927 uint input_len = strlen (input_buf);
10928
10929 logfile_top_var_string ("target", input_buf);
10930
10931 char *hash_buf = NULL;
10932 int hash_len = 0;
10933
10934 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10935
10936 bool hash_fmt_error = 0;
10937
10938 if (hash_len < 1) hash_fmt_error = 1;
10939 if (hash_buf == NULL) hash_fmt_error = 1;
10940
10941 if (hash_fmt_error)
10942 {
10943 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
10944 }
10945 else
10946 {
10947 if (opts_type & OPTS_TYPE_HASH_COPY)
10948 {
10949 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10950
10951 hash_info_tmp->orighash = mystrdup (hash_buf);
10952 }
10953
10954 if (isSalted)
10955 {
10956 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
10957 }
10958
10959 int parser_status = PARSER_OK;
10960
10961 if (hash_mode == 2500)
10962 {
10963 if (hash_len == 0)
10964 {
10965 log_error ("ERROR: hccap file not specified");
10966
10967 return (-1);
10968 }
10969
10970 hashlist_mode = HL_MODE_FILE;
10971
10972 data.hashlist_mode = hashlist_mode;
10973
10974 FILE *fp = fopen (hash_buf, "rb");
10975
10976 if (fp == NULL)
10977 {
10978 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
10979
10980 return (-1);
10981 }
10982
10983 if (hashes_avail < 1)
10984 {
10985 log_error ("ERROR: hccap file is empty or corrupt");
10986
10987 fclose (fp);
10988
10989 return (-1);
10990 }
10991
10992 uint hccap_size = sizeof (hccap_t);
10993
10994 char *in = (char *) mymalloc (hccap_size);
10995
10996 while (!feof (fp))
10997 {
10998 int n = fread (in, hccap_size, 1, fp);
10999
11000 if (n != 1)
11001 {
11002 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11003
11004 break;
11005 }
11006
11007 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11008
11009 if (parser_status != PARSER_OK)
11010 {
11011 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11012
11013 continue;
11014 }
11015
11016 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11017
11018 if ((show == 1) || (left == 1))
11019 {
11020 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11021
11022 char *salt_ptr = (char *) tmp_salt->salt_buf;
11023
11024 int cur_pos = tmp_salt->salt_len;
11025 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11026
11027 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11028
11029 // do the appending task
11030
11031 snprintf (salt_ptr + cur_pos,
11032 rem_len,
11033 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11034 wpa->orig_mac1[0],
11035 wpa->orig_mac1[1],
11036 wpa->orig_mac1[2],
11037 wpa->orig_mac1[3],
11038 wpa->orig_mac1[4],
11039 wpa->orig_mac1[5],
11040 wpa->orig_mac2[0],
11041 wpa->orig_mac2[1],
11042 wpa->orig_mac2[2],
11043 wpa->orig_mac2[3],
11044 wpa->orig_mac2[4],
11045 wpa->orig_mac2[5]);
11046
11047 // memset () the remaining part of the salt
11048
11049 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11050 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11051
11052 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11053
11054 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11055 }
11056
11057 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);
11058 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);
11059
11060 hashes_cnt++;
11061 }
11062
11063 fclose (fp);
11064
11065 myfree (in);
11066 }
11067 else if (hash_mode == 3000)
11068 {
11069 if (hash_len == 32)
11070 {
11071 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11072
11073 hash_t *lm_hash_left = NULL;
11074
11075 if (parser_status == PARSER_OK)
11076 {
11077 lm_hash_left = &hashes_buf[hashes_cnt];
11078
11079 hashes_cnt++;
11080 }
11081 else
11082 {
11083 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11084 }
11085
11086 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11087
11088 hash_t *lm_hash_right = NULL;
11089
11090 if (parser_status == PARSER_OK)
11091 {
11092 lm_hash_right = &hashes_buf[hashes_cnt];
11093
11094 hashes_cnt++;
11095 }
11096 else
11097 {
11098 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11099 }
11100
11101 // show / left
11102
11103 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11104 {
11105 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);
11106 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);
11107 }
11108 }
11109 else
11110 {
11111 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11112
11113 if (parser_status == PARSER_OK)
11114 {
11115 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11116 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11117 }
11118
11119 if (parser_status == PARSER_OK)
11120 {
11121 hashes_cnt++;
11122 }
11123 else
11124 {
11125 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11126 }
11127 }
11128 }
11129 else
11130 {
11131 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11132
11133 if (parser_status == PARSER_OK)
11134 {
11135 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11136 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11137 }
11138
11139 if (parser_status == PARSER_OK)
11140 {
11141 hashes_cnt++;
11142 }
11143 else
11144 {
11145 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11146 }
11147 }
11148 }
11149 }
11150 else if (hashlist_mode == HL_MODE_FILE)
11151 {
11152 char *hashfile = data.hashfile;
11153
11154 FILE *fp;
11155
11156 if ((fp = fopen (hashfile, "rb")) == NULL)
11157 {
11158 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11159
11160 return (-1);
11161 }
11162
11163 uint line_num = 0;
11164
11165 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11166
11167 while (!feof (fp))
11168 {
11169 line_num++;
11170
11171 int line_len = fgetl (fp, line_buf);
11172
11173 if (line_len == 0) continue;
11174
11175 char *hash_buf = NULL;
11176 int hash_len = 0;
11177
11178 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11179
11180 bool hash_fmt_error = 0;
11181
11182 if (hash_len < 1) hash_fmt_error = 1;
11183 if (hash_buf == NULL) hash_fmt_error = 1;
11184
11185 if (hash_fmt_error)
11186 {
11187 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11188
11189 continue;
11190 }
11191
11192 if (username)
11193 {
11194 char *user_buf = NULL;
11195 int user_len = 0;
11196
11197 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11198
11199 if (remove || show)
11200 {
11201 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11202
11203 *user = (user_t *) mymalloc (sizeof (user_t));
11204
11205 user_t *user_ptr = *user;
11206
11207 if (user_buf != NULL)
11208 {
11209 user_ptr->user_name = mystrdup (user_buf);
11210 }
11211 else
11212 {
11213 user_ptr->user_name = mystrdup ("");
11214 }
11215
11216 user_ptr->user_len = user_len;
11217 }
11218 }
11219
11220 if (opts_type & OPTS_TYPE_HASH_COPY)
11221 {
11222 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11223
11224 hash_info_tmp->orighash = mystrdup (hash_buf);
11225 }
11226
11227 if (isSalted)
11228 {
11229 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11230 }
11231
11232 if (hash_mode == 3000)
11233 {
11234 if (hash_len == 32)
11235 {
11236 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11237
11238 if (parser_status < PARSER_GLOBAL_ZERO)
11239 {
11240 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11241
11242 continue;
11243 }
11244
11245 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11246
11247 hashes_cnt++;
11248
11249 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11250
11251 if (parser_status < PARSER_GLOBAL_ZERO)
11252 {
11253 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11254
11255 continue;
11256 }
11257
11258 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11259
11260 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);
11261
11262 hashes_cnt++;
11263
11264 // show / left
11265
11266 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);
11267 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);
11268 }
11269 else
11270 {
11271 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11272
11273 if (parser_status < PARSER_GLOBAL_ZERO)
11274 {
11275 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11276
11277 continue;
11278 }
11279
11280 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);
11281
11282 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11283 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11284
11285 hashes_cnt++;
11286 }
11287 }
11288 else
11289 {
11290 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11291
11292 if (parser_status < PARSER_GLOBAL_ZERO)
11293 {
11294 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11295
11296 continue;
11297 }
11298
11299 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);
11300
11301 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11302 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11303
11304 hashes_cnt++;
11305 }
11306 }
11307
11308 myfree (line_buf);
11309
11310 fclose (fp);
11311
11312 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11313
11314 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11315 }
11316 }
11317 else
11318 {
11319 if (isSalted)
11320 {
11321 hashes_buf[0].salt->salt_len = 8;
11322
11323 // special salt handling
11324
11325 switch (hash_mode)
11326 {
11327 case 1500: hashes_buf[0].salt->salt_len = 2;
11328 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
11329 break;
11330 case 1731: hashes_buf[0].salt->salt_len = 4;
11331 break;
11332 case 2410: hashes_buf[0].salt->salt_len = 4;
11333 break;
11334 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11335 break;
11336 case 3100: hashes_buf[0].salt->salt_len = 1;
11337 break;
11338 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11339 break;
11340 case 5800: hashes_buf[0].salt->salt_len = 16;
11341 break;
11342 case 6800: hashes_buf[0].salt->salt_len = 32;
11343 break;
11344 case 8400: hashes_buf[0].salt->salt_len = 40;
11345 break;
11346 case 8800: hashes_buf[0].salt->salt_len = 16;
11347 break;
11348 case 8900: hashes_buf[0].salt->salt_len = 16;
11349 hashes_buf[0].salt->scrypt_N = 1024;
11350 hashes_buf[0].salt->scrypt_r = 1;
11351 hashes_buf[0].salt->scrypt_p = 1;
11352 break;
11353 case 9100: hashes_buf[0].salt->salt_len = 16;
11354 break;
11355 case 9300: hashes_buf[0].salt->salt_len = 14;
11356 hashes_buf[0].salt->scrypt_N = 16384;
11357 hashes_buf[0].salt->scrypt_r = 1;
11358 hashes_buf[0].salt->scrypt_p = 1;
11359 break;
11360 case 9400: hashes_buf[0].salt->salt_len = 16;
11361 break;
11362 case 9500: hashes_buf[0].salt->salt_len = 16;
11363 break;
11364 case 9600: hashes_buf[0].salt->salt_len = 16;
11365 break;
11366 case 9700: hashes_buf[0].salt->salt_len = 16;
11367 break;
11368 case 9710: hashes_buf[0].salt->salt_len = 16;
11369 break;
11370 case 9720: hashes_buf[0].salt->salt_len = 16;
11371 break;
11372 case 9800: hashes_buf[0].salt->salt_len = 16;
11373 break;
11374 case 9810: hashes_buf[0].salt->salt_len = 16;
11375 break;
11376 case 9820: hashes_buf[0].salt->salt_len = 16;
11377 break;
11378 case 10300: hashes_buf[0].salt->salt_len = 12;
11379 break;
11380 case 11500: hashes_buf[0].salt->salt_len = 4;
11381 break;
11382 case 11600: hashes_buf[0].salt->salt_len = 4;
11383 break;
11384 case 12400: hashes_buf[0].salt->salt_len = 4;
11385 break;
11386 case 12500: hashes_buf[0].salt->salt_len = 8;
11387 break;
11388 case 12600: hashes_buf[0].salt->salt_len = 64;
11389 break;
11390 }
11391
11392 // special esalt handling
11393
11394 switch (hash_mode)
11395 {
11396 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11397 break;
11398 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11399 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11400 break;
11401 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11402 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11403 break;
11404 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11405 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11406 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11407 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11408 break;
11409 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11410 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11411 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11412 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11413 break;
11414 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11415 break;
11416 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11417 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11418 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11419 break;
11420 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11421 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11422 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11423 break;
11424 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11425 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11426 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11427 break;
11428 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11429 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11430 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11431 break;
11432 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11433 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11434 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11435 break;
11436 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11437 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11438 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11439 break;
11440 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11441 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11442 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11443 break;
11444 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
11445 break;
11446 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
11447 break;
11448 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
11449 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
11450 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
11451 break;
11452 }
11453 }
11454
11455 // set hashfile
11456
11457 switch (hash_mode)
11458 {
11459 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11460 break;
11461 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11462 break;
11463 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11464 break;
11465 case 6211: data.hashfile = mystrdup ("hashcat.tc");
11466 break;
11467 case 6212: data.hashfile = mystrdup ("hashcat.tc");
11468 break;
11469 case 6213: data.hashfile = mystrdup ("hashcat.tc");
11470 break;
11471 case 6221: data.hashfile = mystrdup ("hashcat.tc");
11472 break;
11473 case 6222: data.hashfile = mystrdup ("hashcat.tc");
11474 break;
11475 case 6223: data.hashfile = mystrdup ("hashcat.tc");
11476 break;
11477 case 6231: data.hashfile = mystrdup ("hashcat.tc");
11478 break;
11479 case 6232: data.hashfile = mystrdup ("hashcat.tc");
11480 break;
11481 case 6233: data.hashfile = mystrdup ("hashcat.tc");
11482 break;
11483 case 6241: data.hashfile = mystrdup ("hashcat.tc");
11484 break;
11485 case 6242: data.hashfile = mystrdup ("hashcat.tc");
11486 break;
11487 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11488 break;
11489 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11490 break;
11491 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11492 break;
11493 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11494 break;
11495 }
11496
11497 // set default iterations
11498
11499 switch (hash_mode)
11500 {
11501 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11502 break;
11503 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11504 break;
11505 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11506 break;
11507 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11508 break;
11509 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11510 break;
11511 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11512 break;
11513 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11514 break;
11515 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11516 break;
11517 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11518 break;
11519 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11520 break;
11521 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11522 break;
11523 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11524 break;
11525 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11526 break;
11527 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11528 break;
11529 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11530 break;
11531 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11532 break;
11533 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11534 break;
11535 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11536 break;
11537 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11538 break;
11539 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11540 break;
11541 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11542 break;
11543 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11544 break;
11545 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11546 break;
11547 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11548 break;
11549 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11550 break;
11551 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11552 break;
11553 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11554 break;
11555 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11556 break;
11557 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11558 break;
11559 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11560 break;
11561 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11562 break;
11563 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11564 break;
11565 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11566 break;
11567 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11568 break;
11569 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11570 break;
11571 case 8900: hashes_buf[0].salt->salt_iter = 1;
11572 break;
11573 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11574 break;
11575 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11576 break;
11577 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11578 break;
11579 case 9300: hashes_buf[0].salt->salt_iter = 1;
11580 break;
11581 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11582 break;
11583 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11584 break;
11585 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11586 break;
11587 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11588 break;
11589 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11590 break;
11591 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11592 break;
11593 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11594 break;
11595 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11596 break;
11597 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11598 break;
11599 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11600 break;
11601 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11602 break;
11603 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11604 break;
11605 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11606 break;
11607 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11608 break;
11609 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11610 break;
11611 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11612 break;
11613 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11614 break;
11615 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11616 break;
11617 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11618 break;
11619 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11620 break;
11621 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11622 break;
11623 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
11624 break;
11625 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
11626 break;
11627 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
11628 break;
11629 }
11630
11631 hashes_cnt = 1;
11632 }
11633
11634 if (show == 1 || left == 1)
11635 {
11636 for (uint i = 0; i < pot_cnt; i++)
11637 {
11638 pot_t *pot_ptr = &pot[i];
11639
11640 hash_t *hashes_buf = &pot_ptr->hash;
11641
11642 local_free (hashes_buf->digest);
11643
11644 if (isSalted)
11645 {
11646 local_free (hashes_buf->salt);
11647 }
11648 }
11649
11650 local_free (pot);
11651
11652 if (data.quiet == 0) log_info_nn ("");
11653
11654 return (0);
11655 }
11656
11657 if (keyspace == 0)
11658 {
11659 if (hashes_cnt == 0)
11660 {
11661 log_error ("ERROR: No hashes loaded");
11662
11663 return (-1);
11664 }
11665 }
11666
11667 /**
11668 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11669 */
11670
11671 if (data.outfile != NULL)
11672 {
11673 if (data.hashfile != NULL)
11674 {
11675 #ifdef _POSIX
11676 struct stat tmpstat_outfile;
11677 struct stat tmpstat_hashfile;
11678 #endif
11679
11680 #ifdef _WIN
11681 struct stat64 tmpstat_outfile;
11682 struct stat64 tmpstat_hashfile;
11683 #endif
11684
11685 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11686
11687 if (tmp_outfile_fp)
11688 {
11689 #ifdef _POSIX
11690 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11691 #endif
11692
11693 #ifdef _WIN
11694 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11695 #endif
11696
11697 fclose (tmp_outfile_fp);
11698 }
11699
11700 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11701
11702 if (tmp_hashfile_fp)
11703 {
11704 #ifdef _POSIX
11705 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11706 #endif
11707
11708 #ifdef _WIN
11709 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11710 #endif
11711
11712 fclose (tmp_hashfile_fp);
11713 }
11714
11715 if (tmp_outfile_fp && tmp_outfile_fp)
11716 {
11717 tmpstat_outfile.st_mode = 0;
11718 tmpstat_outfile.st_nlink = 0;
11719 tmpstat_outfile.st_uid = 0;
11720 tmpstat_outfile.st_gid = 0;
11721 tmpstat_outfile.st_rdev = 0;
11722 tmpstat_outfile.st_atime = 0;
11723
11724 tmpstat_hashfile.st_mode = 0;
11725 tmpstat_hashfile.st_nlink = 0;
11726 tmpstat_hashfile.st_uid = 0;
11727 tmpstat_hashfile.st_gid = 0;
11728 tmpstat_hashfile.st_rdev = 0;
11729 tmpstat_hashfile.st_atime = 0;
11730
11731 #ifdef _POSIX
11732 tmpstat_outfile.st_blksize = 0;
11733 tmpstat_outfile.st_blocks = 0;
11734
11735 tmpstat_hashfile.st_blksize = 0;
11736 tmpstat_hashfile.st_blocks = 0;
11737 #endif
11738
11739 #ifdef _POSIX
11740 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11741 {
11742 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11743
11744 return (-1);
11745 }
11746 #endif
11747
11748 #ifdef _WIN
11749 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11750 {
11751 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11752
11753 return (-1);
11754 }
11755 #endif
11756 }
11757 }
11758 }
11759
11760 /**
11761 * Remove duplicates
11762 */
11763
11764 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11765
11766 if (isSalted)
11767 {
11768 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11769 }
11770 else
11771 {
11772 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11773 }
11774
11775 uint hashes_cnt_orig = hashes_cnt;
11776
11777 hashes_cnt = 1;
11778
11779 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11780 {
11781 if (isSalted)
11782 {
11783 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11784 {
11785 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11786 }
11787 }
11788 else
11789 {
11790 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11791 }
11792
11793 if (hashes_pos > hashes_cnt)
11794 {
11795 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11796 }
11797
11798 hashes_cnt++;
11799 }
11800
11801 /**
11802 * Potfile removes
11803 */
11804
11805 uint potfile_remove_cracks = 0;
11806
11807 if (potfile_disable == 0)
11808 {
11809 hash_t hash_buf;
11810
11811 hash_buf.digest = mymalloc (dgst_size);
11812 hash_buf.salt = NULL;
11813 hash_buf.esalt = NULL;
11814 hash_buf.hash_info = NULL;
11815 hash_buf.cracked = 0;
11816
11817 if (isSalted)
11818 {
11819 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11820 }
11821
11822 if (esalt_size)
11823 {
11824 hash_buf.esalt = mymalloc (esalt_size);
11825 }
11826
11827 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11828
11829 // no solution for these special hash types (for instane because they use hashfile in output etc)
11830 if ((hash_mode != 5200) &&
11831 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11832 (hash_mode != 9000))
11833 {
11834 FILE *fp = fopen (potfile, "rb");
11835
11836 if (fp != NULL)
11837 {
11838 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11839
11840 // to be safe work with a copy (because of line_len loop, i etc)
11841 // moved up here because it's easier to handle continue case
11842 // it's just 64kb
11843
11844 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
11845
11846 while (!feof (fp))
11847 {
11848 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
11849
11850 if (ptr == NULL) break;
11851
11852 int line_len = strlen (line_buf);
11853
11854 if (line_len == 0) continue;
11855
11856 int iter = MAX_CUT_TRIES;
11857
11858 for (int i = line_len - 1; i && iter; i--, line_len--)
11859 {
11860 if (line_buf[i] != ':') continue;
11861
11862 if (isSalted)
11863 {
11864 memset (hash_buf.salt, 0, sizeof (salt_t));
11865 }
11866
11867 hash_t *found = NULL;
11868
11869 if (hash_mode == 6800)
11870 {
11871 if (i < 64) // 64 = 16 * uint in salt_buf[]
11872 {
11873 // manipulate salt_buf
11874 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11875
11876 hash_buf.salt->salt_len = i;
11877
11878 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11879 }
11880 }
11881 else if (hash_mode == 2500)
11882 {
11883 if (i < 64) // 64 = 16 * uint in salt_buf[]
11884 {
11885 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11886 // manipulate salt_buf
11887
11888 memcpy (line_buf_cpy, line_buf, i);
11889
11890 char *mac2_pos = strrchr (line_buf_cpy, ':');
11891
11892 if (mac2_pos == NULL) continue;
11893
11894 mac2_pos[0] = 0;
11895 mac2_pos++;
11896
11897 if (strlen (mac2_pos) != 12) continue;
11898
11899 char *mac1_pos = strrchr (line_buf_cpy, ':');
11900
11901 if (mac1_pos == NULL) continue;
11902
11903 mac1_pos[0] = 0;
11904 mac1_pos++;
11905
11906 if (strlen (mac1_pos) != 12) continue;
11907
11908 uint essid_length = mac1_pos - line_buf_cpy - 1;
11909
11910 // here we need the ESSID
11911 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11912
11913 hash_buf.salt->salt_len = essid_length;
11914
11915 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11916
11917 if (found)
11918 {
11919 wpa_t *wpa = (wpa_t *) found->esalt;
11920
11921 // compare hex string(s) vs binary MAC address(es)
11922
11923 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11924 {
11925 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
11926 {
11927 found = NULL;
11928
11929 break;
11930 }
11931 }
11932
11933 // early skip ;)
11934 if (!found) continue;
11935
11936 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11937 {
11938 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
11939 {
11940 found = NULL;
11941
11942 break;
11943 }
11944 }
11945 }
11946 }
11947 }
11948 else
11949 {
11950 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
11951
11952 if (parser_status == PARSER_OK)
11953 {
11954 if (isSalted)
11955 {
11956 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11957 }
11958 else
11959 {
11960 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11961 }
11962 }
11963 }
11964
11965 if (found == NULL) continue;
11966
11967 if (!found->cracked) potfile_remove_cracks++;
11968
11969 found->cracked = 1;
11970
11971 if (found) break;
11972
11973 iter--;
11974 }
11975 }
11976
11977 myfree (line_buf_cpy);
11978
11979 myfree (line_buf);
11980
11981 fclose (fp);
11982 }
11983 }
11984
11985 if (esalt_size)
11986 {
11987 local_free (hash_buf.esalt);
11988 }
11989
11990 if (isSalted)
11991 {
11992 local_free (hash_buf.salt);
11993 }
11994
11995 local_free (hash_buf.digest);
11996 }
11997
11998 /**
11999 * Now generate all the buffers required for later
12000 */
12001
12002 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12003
12004 salt_t *salts_buf_new = NULL;
12005 void *esalts_buf_new = NULL;
12006
12007 if (isSalted)
12008 {
12009 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12010
12011 if (esalt_size)
12012 {
12013 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12014 }
12015 }
12016 else
12017 {
12018 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12019 }
12020
12021 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12022
12023 uint digests_cnt = hashes_cnt;
12024 uint digests_done = 0;
12025
12026 size_t size_digests = digests_cnt * dgst_size;
12027 size_t size_shown = digests_cnt * sizeof (uint);
12028
12029 uint *digests_shown = (uint *) mymalloc (size_shown);
12030 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12031
12032 uint salts_cnt = 0;
12033 uint salts_done = 0;
12034
12035 hashinfo_t **hash_info = NULL;
12036
12037 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12038 {
12039 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12040
12041 if (username && (remove || show))
12042 {
12043 uint user_pos;
12044
12045 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12046 {
12047 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12048
12049 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12050 }
12051 }
12052 }
12053
12054 uint *salts_shown = (uint *) mymalloc (size_shown);
12055
12056 salt_t *salt_buf;
12057
12058 {
12059 // copied from inner loop
12060
12061 salt_buf = &salts_buf_new[salts_cnt];
12062
12063 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12064
12065 if (esalt_size)
12066 {
12067 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12068 }
12069
12070 salt_buf->digests_cnt = 0;
12071 salt_buf->digests_done = 0;
12072 salt_buf->digests_offset = 0;
12073
12074 salts_cnt++;
12075 }
12076
12077 if (hashes_buf[0].cracked == 1)
12078 {
12079 digests_shown[0] = 1;
12080
12081 digests_done++;
12082
12083 salt_buf->digests_done++;
12084 }
12085
12086 salt_buf->digests_cnt++;
12087
12088 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12089
12090 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12091 {
12092 hash_info[0] = hashes_buf[0].hash_info;
12093 }
12094
12095 // copy from inner loop
12096
12097 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12098 {
12099 if (isSalted)
12100 {
12101 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12102 {
12103 salt_buf = &salts_buf_new[salts_cnt];
12104
12105 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12106
12107 if (esalt_size)
12108 {
12109 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12110 }
12111
12112 salt_buf->digests_cnt = 0;
12113 salt_buf->digests_done = 0;
12114 salt_buf->digests_offset = hashes_pos;
12115
12116 salts_cnt++;
12117 }
12118 }
12119
12120 if (hashes_buf[hashes_pos].cracked == 1)
12121 {
12122 digests_shown[hashes_pos] = 1;
12123
12124 digests_done++;
12125
12126 salt_buf->digests_done++;
12127 }
12128
12129 salt_buf->digests_cnt++;
12130
12131 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12132
12133 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12134 {
12135 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12136 }
12137 }
12138
12139 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12140 {
12141 salt_t *salt_buf = &salts_buf_new[salt_pos];
12142
12143 if (salt_buf->digests_done == salt_buf->digests_cnt)
12144 {
12145 salts_shown[salt_pos] = 1;
12146
12147 salts_done++;
12148 }
12149
12150 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12151 }
12152
12153 local_free (digests_buf);
12154 local_free (salts_buf);
12155 local_free (esalts_buf);
12156
12157 digests_buf = digests_buf_new;
12158 salts_buf = salts_buf_new;
12159 esalts_buf = esalts_buf_new;
12160
12161 local_free (hashes_buf);
12162
12163 /**
12164 * special modification not set from parser
12165 */
12166
12167 switch (hash_mode)
12168 {
12169 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12170 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12171 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12172 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12173 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12174 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12175 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12176 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12177 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12178 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12179 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12180 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12181 }
12182
12183 if (truecrypt_keyfiles)
12184 {
12185 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12186
12187 char *keyfiles = strdup (truecrypt_keyfiles);
12188
12189 char *keyfile = strtok (keyfiles, ",");
12190
12191 do
12192 {
12193 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12194
12195 } while ((keyfile = strtok (NULL, ",")) != NULL);
12196
12197 free (keyfiles);
12198 }
12199
12200 data.digests_cnt = digests_cnt;
12201 data.digests_done = digests_done;
12202 data.digests_buf = digests_buf;
12203 data.digests_shown = digests_shown;
12204 data.digests_shown_tmp = digests_shown_tmp;
12205
12206 data.salts_cnt = salts_cnt;
12207 data.salts_done = salts_done;
12208 data.salts_buf = salts_buf;
12209 data.salts_shown = salts_shown;
12210
12211 data.esalts_buf = esalts_buf;
12212 data.hash_info = hash_info;
12213
12214 /**
12215 * Automatic Optimizers
12216 */
12217
12218 if (salts_cnt == 1)
12219 opti_type |= OPTI_TYPE_SINGLE_SALT;
12220
12221 if (digests_cnt == 1)
12222 opti_type |= OPTI_TYPE_SINGLE_HASH;
12223
12224 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12225 opti_type |= OPTI_TYPE_NOT_ITERATED;
12226
12227 if (attack_mode == ATTACK_MODE_BF)
12228 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12229
12230 data.opti_type = opti_type;
12231
12232 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12233 {
12234 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12235 {
12236 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12237 {
12238 if (opts_type & OPTS_TYPE_ST_ADD80)
12239 {
12240 opts_type &= ~OPTS_TYPE_ST_ADD80;
12241 opts_type |= OPTS_TYPE_PT_ADD80;
12242 }
12243
12244 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12245 {
12246 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12247 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12248 }
12249
12250 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12251 {
12252 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12253 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12254 }
12255 }
12256 }
12257 }
12258
12259 /**
12260 * Some algorithm, like descrypt, can benefit from JIT compilation
12261 */
12262
12263 int force_jit_compilation = -1;
12264
12265 if (hash_mode == 8900)
12266 {
12267 force_jit_compilation = 8900;
12268 }
12269 else if (hash_mode == 9300)
12270 {
12271 force_jit_compilation = 8900;
12272 }
12273 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12274 {
12275 force_jit_compilation = 1500;
12276 }
12277
12278 /**
12279 * generate bitmap tables
12280 */
12281
12282 const uint bitmap_shift1 = 5;
12283 const uint bitmap_shift2 = 13;
12284
12285 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12286
12287 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12288 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12289 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12290 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12291 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12292 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12293 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12294 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12295
12296 uint bitmap_bits;
12297 uint bitmap_nums;
12298 uint bitmap_mask;
12299 uint bitmap_size;
12300
12301 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12302 {
12303 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12304
12305 bitmap_nums = 1 << bitmap_bits;
12306
12307 bitmap_mask = bitmap_nums - 1;
12308
12309 bitmap_size = bitmap_nums * sizeof (uint);
12310
12311 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12312
12313 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;
12314 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;
12315
12316 break;
12317 }
12318
12319 bitmap_nums = 1 << bitmap_bits;
12320
12321 bitmap_mask = bitmap_nums - 1;
12322
12323 bitmap_size = bitmap_nums * sizeof (uint);
12324
12325 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);
12326 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);
12327
12328 /**
12329 * prepare quick rule
12330 */
12331
12332 data.rule_buf_l = rule_buf_l;
12333 data.rule_buf_r = rule_buf_r;
12334
12335 int rule_len_l = (int) strlen (rule_buf_l);
12336 int rule_len_r = (int) strlen (rule_buf_r);
12337
12338 data.rule_len_l = rule_len_l;
12339 data.rule_len_r = rule_len_r;
12340
12341 /**
12342 * load rules
12343 */
12344
12345 uint *all_kernel_rules_cnt = NULL;
12346
12347 kernel_rule_t **all_kernel_rules_buf = NULL;
12348
12349 if (rp_files_cnt)
12350 {
12351 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12352
12353 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12354 }
12355
12356 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
12357
12358 int rule_len = 0;
12359
12360 for (uint i = 0; i < rp_files_cnt; i++)
12361 {
12362 uint kernel_rules_avail = 0;
12363
12364 uint kernel_rules_cnt = 0;
12365
12366 kernel_rule_t *kernel_rules_buf = NULL;
12367
12368 char *rp_file = rp_files[i];
12369
12370 char in[BLOCK_SIZE] = { 0 };
12371 char out[BLOCK_SIZE] = { 0 };
12372
12373 FILE *fp = NULL;
12374
12375 uint rule_line = 0;
12376
12377 if ((fp = fopen (rp_file, "rb")) == NULL)
12378 {
12379 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12380
12381 return (-1);
12382 }
12383
12384 while (!feof (fp))
12385 {
12386 memset (rule_buf, 0, HCBUFSIZ);
12387
12388 rule_len = fgetl (fp, rule_buf);
12389
12390 rule_line++;
12391
12392 if (rule_len == 0) continue;
12393
12394 if (rule_buf[0] == '#') continue;
12395
12396 if (kernel_rules_avail == kernel_rules_cnt)
12397 {
12398 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12399
12400 kernel_rules_avail += INCR_RULES;
12401 }
12402
12403 memset (in, 0, BLOCK_SIZE);
12404 memset (out, 0, BLOCK_SIZE);
12405
12406 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12407
12408 if (result == -1)
12409 {
12410 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12411
12412 continue;
12413 }
12414
12415 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12416 {
12417 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12418
12419 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12420
12421 continue;
12422 }
12423
12424 /* its so slow
12425 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12426 {
12427 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12428
12429 continue;
12430 }
12431 */
12432
12433 kernel_rules_cnt++;
12434 }
12435
12436 fclose (fp);
12437
12438 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12439
12440 all_kernel_rules_buf[i] = kernel_rules_buf;
12441 }
12442
12443 /**
12444 * merge rules or automatic rule generator
12445 */
12446
12447 uint kernel_rules_cnt = 0;
12448
12449 kernel_rule_t *kernel_rules_buf = NULL;
12450
12451 if (attack_mode == ATTACK_MODE_STRAIGHT)
12452 {
12453 if (rp_files_cnt)
12454 {
12455 kernel_rules_cnt = 1;
12456
12457 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12458
12459 repeats[0] = kernel_rules_cnt;
12460
12461 for (uint i = 0; i < rp_files_cnt; i++)
12462 {
12463 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12464
12465 repeats[i + 1] = kernel_rules_cnt;
12466 }
12467
12468 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12469
12470 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12471
12472 for (uint i = 0; i < kernel_rules_cnt; i++)
12473 {
12474 uint out_pos = 0;
12475
12476 kernel_rule_t *out = &kernel_rules_buf[i];
12477
12478 for (uint j = 0; j < rp_files_cnt; j++)
12479 {
12480 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12481 uint in_pos;
12482
12483 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12484
12485 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12486 {
12487 if (out_pos == RULES_MAX - 1)
12488 {
12489 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12490
12491 break;
12492 }
12493
12494 out->cmds[out_pos] = in->cmds[in_pos];
12495 }
12496 }
12497 }
12498
12499 local_free (repeats);
12500 }
12501 else if (rp_gen)
12502 {
12503 uint kernel_rules_avail = 0;
12504
12505 while (kernel_rules_cnt < rp_gen)
12506 {
12507 if (kernel_rules_avail == kernel_rules_cnt)
12508 {
12509 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12510
12511 kernel_rules_avail += INCR_RULES;
12512 }
12513
12514 memset (rule_buf, 0, HCBUFSIZ);
12515
12516 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12517
12518 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12519
12520 kernel_rules_cnt++;
12521 }
12522 }
12523 }
12524
12525 myfree (rule_buf);
12526
12527 /**
12528 * generate NOP rules
12529 */
12530
12531 if (kernel_rules_cnt == 0)
12532 {
12533 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12534
12535 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12536
12537 kernel_rules_cnt++;
12538 }
12539
12540 data.kernel_rules_cnt = kernel_rules_cnt;
12541 data.kernel_rules_buf = kernel_rules_buf;
12542
12543 /**
12544 * OpenCL platforms: detect
12545 */
12546
12547 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
12548 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
12549
12550 cl_uint platforms_cnt = 0;
12551 cl_uint platform_devices_cnt = 0;
12552
12553 if (keyspace == 0)
12554 {
12555 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12556
12557 if (platforms_cnt == 0)
12558 {
12559 log_info ("");
12560 log_info ("ATTENTION! No OpenCL compatible platform found");
12561 log_info ("");
12562 log_info ("You're probably missing the OpenCL runtime installation");
12563 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
12564 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
12565 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
12566 log_info ("");
12567
12568 return (-1);
12569 }
12570
12571 if (opencl_platforms_filter != (uint) -1)
12572 {
12573 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
12574
12575 if (opencl_platforms_filter > platform_cnt_mask)
12576 {
12577 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
12578
12579 return (-1);
12580 }
12581 }
12582 }
12583
12584 /**
12585 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12586 */
12587
12588 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12589 {
12590 cl_platform_id platform = platforms[platform_id];
12591
12592 char platform_vendor[INFOSZ] = { 0 };
12593
12594 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12595
12596 #ifdef HAVE_HWMON
12597 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12598 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12599 {
12600 // make sure that we do not directly control the fan for NVidia
12601
12602 gpu_temp_retain = 0;
12603
12604 data.gpu_temp_retain = gpu_temp_retain;
12605 }
12606 #endif // HAVE_NVML || HAVE_NVAPI
12607 #endif
12608 }
12609
12610 /**
12611 * OpenCL device types:
12612 * In case the user did not specify --opencl-device-types and the user runs hashcat in a system with only a CPU only he probably want to use that CPU.
12613 * In such a case, automatically enable CPU device type support, since it's disabled by default.
12614 */
12615
12616 if (opencl_device_types == NULL)
12617 {
12618 cl_device_type device_types_all = 0;
12619
12620 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12621 {
12622 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12623
12624 cl_platform_id platform = platforms[platform_id];
12625
12626 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12627
12628 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12629 {
12630 cl_device_id device = platform_devices[platform_devices_id];
12631
12632 cl_device_type device_type;
12633
12634 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12635
12636 device_types_all |= device_type;
12637 }
12638 }
12639
12640 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
12641 {
12642 device_types_filter |= CL_DEVICE_TYPE_CPU;
12643 }
12644 }
12645
12646 /**
12647 * OpenCL devices: simply push all devices from all platforms into the same device array
12648 */
12649
12650 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12651
12652 data.devices_param = devices_param;
12653
12654 uint devices_cnt = 0;
12655
12656 uint devices_active = 0;
12657
12658 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12659 {
12660 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12661
12662 cl_platform_id platform = platforms[platform_id];
12663
12664 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12665
12666 char platform_vendor[INFOSZ] = { 0 };
12667
12668 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12669
12670 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
12671 // this causes trouble with vendor id based macros
12672 // we'll assign generic to those without special optimization available
12673
12674 cl_uint vendor_id = 0;
12675
12676 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
12677 {
12678 vendor_id = VENDOR_ID_AMD;
12679 }
12680 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
12681 {
12682 vendor_id = VENDOR_ID_APPLE;
12683 }
12684 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
12685 {
12686 vendor_id = VENDOR_ID_INTEL_BEIGNET;
12687 }
12688 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
12689 {
12690 vendor_id = VENDOR_ID_INTEL_SDK;
12691 }
12692 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
12693 {
12694 vendor_id = VENDOR_ID_MESA;
12695 }
12696 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12697 {
12698 vendor_id = VENDOR_ID_NV;
12699 }
12700 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
12701 {
12702 vendor_id = VENDOR_ID_POCL;
12703 }
12704 else
12705 {
12706 vendor_id = VENDOR_ID_GENERIC;
12707 }
12708
12709 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12710 {
12711 size_t param_value_size = 0;
12712
12713 const uint device_id = devices_cnt;
12714
12715 hc_device_param_t *device_param = &data.devices_param[device_id];
12716
12717 device_param->vendor_id = vendor_id;
12718
12719 device_param->device = platform_devices[platform_devices_id];
12720
12721 device_param->device_id = device_id;
12722
12723 device_param->platform_devices_id = platform_devices_id;
12724
12725 // device_type
12726
12727 cl_device_type device_type;
12728
12729 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12730
12731 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12732
12733 device_param->device_type = device_type;
12734
12735 // device_name
12736
12737 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
12738
12739 char *device_name = (char *) mymalloc (param_value_size);
12740
12741 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
12742
12743 device_param->device_name = device_name;
12744
12745 // tuning db
12746
12747 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
12748
12749 // device_version
12750
12751 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
12752
12753 char *device_version = (char *) mymalloc (param_value_size);
12754
12755 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
12756
12757 device_param->device_version = device_version;
12758
12759 // device_opencl_version
12760
12761 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
12762
12763 char *device_opencl_version = (char *) mymalloc (param_value_size);
12764
12765 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
12766
12767 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
12768
12769 myfree (device_opencl_version);
12770
12771 // vector_width
12772
12773 cl_uint vector_width;
12774
12775 if (opencl_vector_width_chgd == 0)
12776 {
12777 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
12778 {
12779 if (opti_type & OPTI_TYPE_USES_BITS_64)
12780 {
12781 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
12782 }
12783 else
12784 {
12785 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12786 }
12787 }
12788 else
12789 {
12790 vector_width = (cl_uint) tuningdb_entry->vector_width;
12791 }
12792 }
12793 else
12794 {
12795 vector_width = opencl_vector_width;
12796 }
12797
12798 if (vector_width > 16) vector_width = 16;
12799
12800 device_param->vector_width = vector_width;
12801
12802 // max_compute_units
12803
12804 cl_uint device_processors;
12805
12806 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12807
12808 device_param->device_processors = device_processors;
12809
12810 // device_maxmem_alloc
12811 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
12812
12813 cl_ulong device_maxmem_alloc;
12814
12815 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12816
12817 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
12818
12819 // device_global_mem
12820
12821 cl_ulong device_global_mem;
12822
12823 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12824
12825 device_param->device_global_mem = device_global_mem;
12826
12827 // max_work_group_size
12828
12829 size_t device_maxworkgroup_size;
12830
12831 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
12832
12833 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
12834
12835 // max_clock_frequency
12836
12837 cl_uint device_maxclock_frequency;
12838
12839 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12840
12841 device_param->device_maxclock_frequency = device_maxclock_frequency;
12842
12843 // device_endian_little
12844
12845 cl_bool device_endian_little;
12846
12847 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
12848
12849 if (device_endian_little == CL_FALSE)
12850 {
12851 log_info ("Device #%u: WARNING: not little endian device", device_id + 1);
12852
12853 device_param->skipped = 1;
12854 }
12855
12856 // device_available
12857
12858 cl_bool device_available;
12859
12860 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
12861
12862 if (device_available == CL_FALSE)
12863 {
12864 log_info ("Device #%u: WARNING: device not available", device_id + 1);
12865
12866 device_param->skipped = 1;
12867 }
12868
12869 // device_compiler_available
12870
12871 cl_bool device_compiler_available;
12872
12873 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
12874
12875 if (device_compiler_available == CL_FALSE)
12876 {
12877 log_info ("Device #%u: WARNING: device no compiler available", device_id + 1);
12878
12879 device_param->skipped = 1;
12880 }
12881
12882 // device_execution_capabilities
12883
12884 cl_device_exec_capabilities device_execution_capabilities;
12885
12886 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
12887
12888 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
12889 {
12890 log_info ("Device #%u: WARNING: device does not support executing kernels", device_id + 1);
12891
12892 device_param->skipped = 1;
12893 }
12894
12895 // device_extensions
12896
12897 size_t device_extensions_size;
12898
12899 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
12900
12901 char *device_extensions = mymalloc (device_extensions_size + 1);
12902
12903 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
12904
12905 if (strstr (device_extensions, "base_atomics") == 0)
12906 {
12907 log_info ("Device #%u: WARNING: device does not support base atomics", device_id + 1);
12908
12909 device_param->skipped = 1;
12910 }
12911
12912 if (strstr (device_extensions, "byte_addressable_store") == 0)
12913 {
12914 log_info ("Device #%u: WARNING: device does not support byte addressable store", device_id + 1);
12915
12916 device_param->skipped = 1;
12917 }
12918
12919 myfree (device_extensions);
12920
12921 // device_local_mem_size
12922
12923 cl_ulong device_local_mem_size;
12924
12925 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
12926
12927 if (device_local_mem_size < 32768)
12928 {
12929 log_info ("Device #%u: WARNING: device local mem size is too small", device_id + 1);
12930
12931 device_param->skipped = 1;
12932 }
12933
12934
12935 // skipped
12936
12937 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
12938 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
12939
12940 // driver_version
12941
12942 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
12943
12944 char *driver_version = (char *) mymalloc (param_value_size);
12945
12946 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
12947
12948 device_param->driver_version = driver_version;
12949
12950 // device_name_chksum
12951
12952 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12953
12954 #if __x86_64__
12955 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);
12956 #else
12957 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);
12958 #endif
12959
12960 uint device_name_digest[4] = { 0 };
12961
12962 md5_64 ((uint *) device_name_chksum, device_name_digest);
12963
12964 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
12965
12966 device_param->device_name_chksum = device_name_chksum;
12967
12968 // device_processor_cores
12969
12970 if (device_type & CL_DEVICE_TYPE_CPU)
12971 {
12972 cl_uint device_processor_cores = 1;
12973
12974 device_param->device_processor_cores = device_processor_cores;
12975 }
12976
12977 if (device_type & CL_DEVICE_TYPE_GPU)
12978 {
12979 if (vendor_id == VENDOR_ID_AMD)
12980 {
12981 cl_uint device_processor_cores = 0;
12982
12983 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12984
12985 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12986
12987 device_param->device_processor_cores = device_processor_cores;
12988 }
12989 else if (vendor_id == VENDOR_ID_NV)
12990 {
12991 cl_uint kernel_exec_timeout = 0;
12992
12993 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12994
12995 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12996
12997 device_param->kernel_exec_timeout = kernel_exec_timeout;
12998
12999 cl_uint device_processor_cores = 0;
13000
13001 #define CL_DEVICE_WARP_SIZE_NV 0x4003
13002
13003 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
13004
13005 device_param->device_processor_cores = device_processor_cores;
13006
13007 cl_uint sm_minor = 0;
13008 cl_uint sm_major = 0;
13009
13010 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
13011 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
13012
13013 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
13014 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
13015
13016 device_param->sm_minor = sm_minor;
13017 device_param->sm_major = sm_major;
13018 }
13019 else
13020 {
13021 cl_uint device_processor_cores = 1;
13022
13023 device_param->device_processor_cores = device_processor_cores;
13024 }
13025 }
13026
13027 // display results
13028
13029 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13030 {
13031 if (device_param->skipped == 0)
13032 {
13033 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
13034 device_id + 1,
13035 device_name,
13036 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
13037 (unsigned int) (device_global_mem / 1024 / 1024),
13038 (unsigned int) (device_maxclock_frequency),
13039 (unsigned int) device_processors);
13040 }
13041 else
13042 {
13043 log_info ("Device #%u: %s, skipped",
13044 device_id + 1,
13045 device_name);
13046 }
13047 }
13048
13049 // common driver check
13050
13051 if (device_param->skipped == 0)
13052 {
13053 if (device_type & CL_DEVICE_TYPE_GPU)
13054 {
13055 if (vendor_id == VENDOR_ID_AMD)
13056 {
13057 int catalyst_check = (force == 1) ? 0 : 1;
13058
13059 int catalyst_warn = 0;
13060
13061 int catalyst_broken = 0;
13062
13063 if (catalyst_check == 1)
13064 {
13065 catalyst_warn = 1;
13066
13067 // v14.9 and higher
13068 if (atoi (device_param->driver_version) >= 1573)
13069 {
13070 catalyst_warn = 0;
13071 }
13072
13073 catalyst_check = 0;
13074 }
13075
13076 if (catalyst_broken == 1)
13077 {
13078 log_info ("");
13079 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
13080 log_info ("It will pass over cracked hashes and does not report them as cracked");
13081 log_info ("You are STRONGLY encouraged not to use it");
13082 log_info ("You can use --force to override this but do not post error reports if you do so");
13083 log_info ("");
13084
13085 return (-1);
13086 }
13087
13088 if (catalyst_warn == 1)
13089 {
13090 log_info ("");
13091 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13092 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13093 log_info ("See hashcat's homepage for official supported catalyst drivers");
13094 #ifdef _WIN
13095 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13096 #endif
13097 log_info ("You can use --force to override this but do not post error reports if you do so");
13098 log_info ("");
13099
13100 return (-1);
13101 }
13102 }
13103 else if (vendor_id == VENDOR_ID_NV)
13104 {
13105 if (device_param->kernel_exec_timeout != 0)
13106 {
13107 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);
13108 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
13109 }
13110 }
13111 }
13112
13113 if (device_type & CL_DEVICE_TYPE_CPU)
13114 {
13115 if (vendor_id == VENDOR_ID_AMD)
13116 {
13117 if (force == 0)
13118 {
13119 log_info ("");
13120 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
13121 log_info ("You are STRONGLY encouraged not to use it");
13122 log_info ("You can use --force to override this but do not post error reports if you do so");
13123 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
13124 log_info ("");
13125
13126 return (-1);
13127 }
13128 }
13129 }
13130
13131 /**
13132 * kernel accel and loops tuning db adjustment
13133 */
13134
13135 device_param->kernel_accel_min = 1;
13136 device_param->kernel_accel_max = 1024;
13137
13138 device_param->kernel_loops_min = 1;
13139 device_param->kernel_loops_max = 1024;
13140
13141 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13142
13143 if (tuningdb_entry)
13144 {
13145 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13146 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13147
13148 if (_kernel_accel)
13149 {
13150 device_param->kernel_accel_min = _kernel_accel;
13151 device_param->kernel_accel_max = _kernel_accel;
13152 }
13153
13154 if (_kernel_loops)
13155 {
13156 if (workload_profile == 1)
13157 {
13158 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13159 }
13160 else if (workload_profile == 2)
13161 {
13162 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13163 }
13164
13165 device_param->kernel_loops_min = _kernel_loops;
13166 device_param->kernel_loops_max = _kernel_loops;
13167 }
13168 }
13169
13170 // commandline parameters overwrite tuningdb entries
13171
13172 if (kernel_accel)
13173 {
13174 device_param->kernel_accel_min = kernel_accel;
13175 device_param->kernel_accel_max = kernel_accel;
13176 }
13177
13178 if (kernel_loops)
13179 {
13180 device_param->kernel_loops_min = kernel_loops;
13181 device_param->kernel_loops_max = kernel_loops;
13182 }
13183
13184 /**
13185 * activate device
13186 */
13187
13188 devices_active++;
13189 }
13190
13191 // next please
13192
13193 devices_cnt++;
13194 }
13195 }
13196
13197 if (keyspace == 0 && devices_active == 0)
13198 {
13199 log_error ("ERROR: No devices found/left");
13200
13201 return (-1);
13202 }
13203
13204 // additional check to see if the user has chosen a device that is not within the range of available devices (i.e. larger than devices_cnt)
13205
13206 if (devices_filter != (uint) -1)
13207 {
13208 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
13209
13210 if (devices_filter > devices_cnt_mask)
13211 {
13212 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
13213
13214 return (-1);
13215 }
13216 }
13217
13218 data.devices_cnt = devices_cnt;
13219
13220 data.devices_active = devices_active;
13221
13222 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13223 {
13224 log_info ("");
13225 }
13226
13227 /**
13228 * HM devices: init
13229 */
13230
13231 #ifdef HAVE_HWMON
13232 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13233 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13234 #endif
13235
13236 #ifdef HAVE_ADL
13237 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13238 #endif
13239
13240 if (gpu_temp_disable == 0)
13241 {
13242 #if defined(WIN) && defined(HAVE_NVAPI)
13243 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13244
13245 if (nvapi_init (nvapi) == 0)
13246 data.hm_nv = nvapi;
13247
13248 if (data.hm_nv)
13249 {
13250 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13251 {
13252 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13253
13254 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13255
13256 int tmp_out = 0;
13257
13258 for (int i = 0; i < tmp_in; i++)
13259 {
13260 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13261 }
13262
13263 for (int i = 0; i < tmp_out; i++)
13264 {
13265 NV_GPU_COOLER_SETTINGS pCoolerSettings;
13266
13267 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
13268
13269 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;
13270 }
13271 }
13272 }
13273 #endif // WIN && HAVE_NVAPI
13274
13275 #if defined(LINUX) && defined(HAVE_NVML)
13276 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13277
13278 if (nvml_init (nvml) == 0)
13279 data.hm_nv = nvml;
13280
13281 if (data.hm_nv)
13282 {
13283 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13284 {
13285 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13286
13287 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13288
13289 int tmp_out = 0;
13290
13291 for (int i = 0; i < tmp_in; i++)
13292 {
13293 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13294 }
13295
13296 for (int i = 0; i < tmp_out; i++)
13297 {
13298 unsigned int speed;
13299
13300 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;
13301 }
13302 }
13303 }
13304 #endif // LINUX && HAVE_NVML
13305
13306 data.hm_amd = NULL;
13307
13308 #ifdef HAVE_ADL
13309 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13310
13311 if (adl_init (adl) == 0)
13312 data.hm_amd = adl;
13313
13314 if (data.hm_amd)
13315 {
13316 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13317 {
13318 // total number of adapters
13319
13320 int hm_adapters_num;
13321
13322 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13323
13324 // adapter info
13325
13326 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13327
13328 if (lpAdapterInfo == NULL) return (-1);
13329
13330 // get a list (of ids of) valid/usable adapters
13331
13332 int num_adl_adapters = 0;
13333
13334 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13335
13336 if (num_adl_adapters > 0)
13337 {
13338 hc_thread_mutex_lock (mux_adl);
13339
13340 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13341
13342 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13343
13344 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13345 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13346
13347 hc_thread_mutex_unlock (mux_adl);
13348 }
13349
13350 myfree (valid_adl_device_list);
13351 myfree (lpAdapterInfo);
13352 }
13353 }
13354 #endif // HAVE_ADL
13355
13356 if (data.hm_amd == NULL && data.hm_nv == NULL)
13357 {
13358 gpu_temp_disable = 1;
13359 }
13360 }
13361
13362 /**
13363 * OpenCL devices: allocate buffer for device specific information
13364 */
13365
13366 #ifdef HAVE_HWMON
13367 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13368
13369 #ifdef HAVE_ADL
13370 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13371
13372 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13373 #endif // ADL
13374 #endif
13375
13376 /**
13377 * enable custom signal handler(s)
13378 */
13379
13380 if (benchmark == 0)
13381 {
13382 hc_signal (sigHandler_default);
13383 }
13384 else
13385 {
13386 hc_signal (sigHandler_benchmark);
13387 }
13388
13389 /**
13390 * User-defined GPU temp handling
13391 */
13392
13393 #ifdef HAVE_HWMON
13394 if (gpu_temp_disable == 1)
13395 {
13396 gpu_temp_abort = 0;
13397 gpu_temp_retain = 0;
13398 }
13399
13400 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13401 {
13402 if (gpu_temp_abort < gpu_temp_retain)
13403 {
13404 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13405
13406 return (-1);
13407 }
13408 }
13409
13410 data.gpu_temp_disable = gpu_temp_disable;
13411 data.gpu_temp_abort = gpu_temp_abort;
13412 data.gpu_temp_retain = gpu_temp_retain;
13413 #endif
13414
13415 /**
13416 * inform the user
13417 */
13418
13419 if (data.quiet == 0)
13420 {
13421 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13422
13423 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);
13424
13425 if (attack_mode == ATTACK_MODE_STRAIGHT)
13426 {
13427 log_info ("Rules: %u", kernel_rules_cnt);
13428 }
13429
13430 if (opti_type)
13431 {
13432 log_info ("Applicable Optimizers:");
13433
13434 for (uint i = 0; i < 32; i++)
13435 {
13436 const uint opti_bit = 1u << i;
13437
13438 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13439 }
13440 }
13441
13442 /**
13443 * Watchdog and Temperature balance
13444 */
13445
13446 #ifdef HAVE_HWMON
13447 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13448 {
13449 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13450 }
13451
13452 if (gpu_temp_abort == 0)
13453 {
13454 log_info ("Watchdog: Temperature abort trigger disabled");
13455 }
13456 else
13457 {
13458 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13459 }
13460
13461 if (gpu_temp_retain == 0)
13462 {
13463 log_info ("Watchdog: Temperature retain trigger disabled");
13464 }
13465 else
13466 {
13467 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13468 }
13469
13470 if (data.quiet == 0) log_info ("");
13471 #endif
13472 }
13473
13474 /**
13475 * HM devices: copy
13476 */
13477
13478 if (gpu_temp_disable == 0)
13479 {
13480 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13481 {
13482 hc_device_param_t *device_param = &data.devices_param[device_id];
13483
13484 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13485
13486 if (device_param->skipped) continue;
13487
13488 const uint platform_devices_id = device_param->platform_devices_id;
13489
13490 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13491 if (device_param->vendor_id == VENDOR_ID_NV)
13492 {
13493 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13494 }
13495 #endif
13496
13497 #ifdef HAVE_ADL
13498 if (device_param->vendor_id == VENDOR_ID_AMD)
13499 {
13500 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13501 }
13502 #endif
13503 }
13504 }
13505
13506 /*
13507 * Temporary fix:
13508 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13509 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13510 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13511 * Driver / ADL bug?
13512 */
13513
13514 #ifdef HAVE_ADL
13515 if (powertune_enable == 1)
13516 {
13517 hc_thread_mutex_lock (mux_adl);
13518
13519 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13520 {
13521 hc_device_param_t *device_param = &data.devices_param[device_id];
13522
13523 if (device_param->skipped) continue;
13524
13525 if (data.hm_device[device_id].od_version == 6)
13526 {
13527 // set powertune value only
13528
13529 int powertune_supported = 0;
13530
13531 int ADL_rc = 0;
13532
13533 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13534 {
13535 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13536
13537 return (-1);
13538 }
13539
13540 if (powertune_supported != 0)
13541 {
13542 // powertune set
13543 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13544
13545 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13546 {
13547 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13548
13549 return (-1);
13550 }
13551
13552 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13553 {
13554 log_error ("ERROR: Failed to set new ADL PowerControl values");
13555
13556 return (-1);
13557 }
13558 }
13559 }
13560 }
13561
13562 hc_thread_mutex_unlock (mux_adl);
13563 }
13564 #endif // HAVE_ADK
13565 #endif // HAVE_HWMON
13566
13567 #ifdef DEBUG
13568 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
13569 #endif
13570
13571 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
13572
13573 uint kernel_power_all = 0;
13574
13575 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13576 {
13577 /**
13578 * host buffer
13579 */
13580
13581 hc_device_param_t *device_param = &data.devices_param[device_id];
13582
13583 if (device_param->skipped) continue;
13584
13585 /**
13586 * device properties
13587 */
13588
13589 const char *device_name_chksum = device_param->device_name_chksum;
13590 const u32 device_processors = device_param->device_processors;
13591 const u32 device_processor_cores = device_param->device_processor_cores;
13592
13593 /**
13594 * create context for each device
13595 */
13596
13597 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
13598
13599 /**
13600 * create command-queue
13601 */
13602
13603 // not supported with NV
13604 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13605
13606 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
13607
13608 /**
13609 * kernel threads: some algorithms need a fixed kernel-threads count
13610 * because of shared memory usage or bitslice
13611 * there needs to be some upper limit, otherwise there's too much overhead
13612 */
13613
13614 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
13615
13616 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
13617 {
13618 kernel_threads = KERNEL_THREADS_MAX_CPU;
13619 }
13620
13621 if (hash_mode == 1500) kernel_threads = 64; // DES
13622 if (hash_mode == 3000) kernel_threads = 64; // DES
13623 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
13624 if (hash_mode == 7500) kernel_threads = 64; // RC4
13625 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
13626 if (hash_mode == 9700) kernel_threads = 64; // RC4
13627 if (hash_mode == 9710) kernel_threads = 64; // RC4
13628 if (hash_mode == 9800) kernel_threads = 64; // RC4
13629 if (hash_mode == 9810) kernel_threads = 64; // RC4
13630 if (hash_mode == 10400) kernel_threads = 64; // RC4
13631 if (hash_mode == 10410) kernel_threads = 64; // RC4
13632 if (hash_mode == 10500) kernel_threads = 64; // RC4
13633 if (hash_mode == 13100) kernel_threads = 64; // RC4
13634
13635 /**
13636 * create input buffers on device : calculate size of fixed memory buffers
13637 */
13638
13639 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
13640 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13641
13642 device_param->size_root_css = size_root_css;
13643 device_param->size_markov_css = size_markov_css;
13644
13645 size_t size_results = kernel_threads * sizeof (uint);
13646
13647 device_param->size_results = size_results;
13648
13649 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13650 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13651
13652 size_t size_plains = digests_cnt * sizeof (plain_t);
13653 size_t size_salts = salts_cnt * sizeof (salt_t);
13654 size_t size_esalts = salts_cnt * esalt_size;
13655
13656 device_param->size_plains = size_plains;
13657 device_param->size_digests = size_digests;
13658 device_param->size_shown = size_shown;
13659 device_param->size_salts = size_salts;
13660
13661 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
13662 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
13663 size_t size_tm = 32 * sizeof (bs_word_t);
13664
13665 // scryptV stuff
13666
13667 size_t size_scryptV = 1;
13668
13669 if ((hash_mode == 8900) || (hash_mode == 9300))
13670 {
13671 uint tmto_start = 0;
13672 uint tmto_stop = 10;
13673
13674 if (scrypt_tmto)
13675 {
13676 tmto_start = scrypt_tmto;
13677 }
13678 else
13679 {
13680 // in case the user did not specify the tmto manually
13681 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13682 // but set the lower end only in case the user has a device with too less memory
13683
13684 if (hash_mode == 8900)
13685 {
13686 if (device_param->vendor_id == VENDOR_ID_AMD)
13687 {
13688 tmto_start = 1;
13689 }
13690 else if (device_param->vendor_id == VENDOR_ID_NV)
13691 {
13692 tmto_start = 2;
13693 }
13694 }
13695 else if (hash_mode == 9300)
13696 {
13697 if (device_param->vendor_id == VENDOR_ID_AMD)
13698 {
13699 tmto_start = 2;
13700 }
13701 else if (device_param->vendor_id == VENDOR_ID_NV)
13702 {
13703 tmto_start = 2;
13704 }
13705 }
13706 }
13707
13708 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13709 {
13710 // TODO: in theory the following calculation needs to be done per salt, not global
13711 // we assume all hashes have the same scrypt settings
13712
13713 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13714
13715 size_scryptV /= 1 << tmto;
13716
13717 size_scryptV *= device_processors * device_processor_cores;
13718
13719 if (size_scryptV > device_param->device_maxmem_alloc)
13720 {
13721 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13722
13723 continue;
13724 }
13725
13726 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13727 {
13728 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13729 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
13730 }
13731
13732 break;
13733 }
13734
13735 if (data.salts_buf[0].scrypt_phy == 0)
13736 {
13737 log_error ("ERROR: can't allocate enough device memory");
13738
13739 return -1;
13740 }
13741
13742 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13743 }
13744
13745 /**
13746 * some algorithms need a fixed kernel-loops count
13747 */
13748
13749 if (hash_mode == 1500)
13750 {
13751 const u32 kernel_loops_fixed = 1024;
13752
13753 device_param->kernel_loops_min = kernel_loops_fixed;
13754 device_param->kernel_loops_max = kernel_loops_fixed;
13755 }
13756
13757 if (hash_mode == 3000)
13758 {
13759 const u32 kernel_loops_fixed = 1024;
13760
13761 device_param->kernel_loops_min = kernel_loops_fixed;
13762 device_param->kernel_loops_max = kernel_loops_fixed;
13763 }
13764
13765 if (hash_mode == 8900)
13766 {
13767 const u32 kernel_loops_fixed = 1;
13768
13769 device_param->kernel_loops_min = kernel_loops_fixed;
13770 device_param->kernel_loops_max = kernel_loops_fixed;
13771 }
13772
13773 if (hash_mode == 9300)
13774 {
13775 const u32 kernel_loops_fixed = 1;
13776
13777 device_param->kernel_loops_min = kernel_loops_fixed;
13778 device_param->kernel_loops_max = kernel_loops_fixed;
13779 }
13780
13781 if (hash_mode == 12500)
13782 {
13783 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
13784
13785 device_param->kernel_loops_min = kernel_loops_fixed;
13786 device_param->kernel_loops_max = kernel_loops_fixed;
13787 }
13788
13789 /**
13790 * some algorithms have a maximum kernel-loops count
13791 */
13792
13793 if (attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
13794 {
13795 if (data.salts_buf[0].salt_iter < device_param->kernel_loops_max)
13796 {
13797 device_param->kernel_loops_max = data.salts_buf[0].salt_iter;
13798 }
13799 }
13800
13801 /**
13802 * some algorithms need a special kernel-accel
13803 */
13804
13805 if (hash_mode == 8900)
13806 {
13807 device_param->kernel_accel_min = 1;
13808 device_param->kernel_accel_max = 64;
13809 }
13810
13811 if (hash_mode == 9300)
13812 {
13813 device_param->kernel_accel_min = 1;
13814 device_param->kernel_accel_max = 64;
13815 }
13816
13817 u32 kernel_accel_min = device_param->kernel_accel_min;
13818 u32 kernel_accel_max = device_param->kernel_accel_max;
13819
13820 // find out if we would request too much memory on memory blocks which are based on kernel_accel
13821
13822 size_t size_pws = 4;
13823 size_t size_tmps = 4;
13824 size_t size_hooks = 4;
13825
13826 while (kernel_accel_max >= kernel_accel_min)
13827 {
13828 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
13829
13830 // size_pws
13831
13832 size_pws = kernel_power_max * sizeof (pw_t);
13833
13834 // size_tmps
13835
13836 switch (hash_mode)
13837 {
13838 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
13839 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13840 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13841 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13842 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
13843 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
13844 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
13845 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
13846 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
13847 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
13848 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13849 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13850 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13851 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13852 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13853 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13854 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13855 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13856 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13857 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13858 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13859 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13860 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13861 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
13862 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
13863 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
13864 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
13865 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
13866 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13867 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13868 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
13869 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
13870 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13871 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
13872 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13873 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
13874 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
13875 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13876 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13877 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
13878 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
13879 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
13880 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13881 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
13882 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
13883 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
13884 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
13885 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13886 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
13887 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
13888 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
13889 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
13890 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13891 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
13892 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
13893 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
13894 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
13895 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
13896 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13897 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13898 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13899 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
13900 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
13901 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
13902 };
13903
13904 // size_hooks
13905
13906 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13907 {
13908 // none yet
13909 }
13910
13911 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
13912 // if not, decrease amplifier and try again
13913
13914 int skip = 0;
13915
13916 if (size_pws > device_param->device_maxmem_alloc) skip = 1;
13917 if (size_tmps > device_param->device_maxmem_alloc) skip = 1;
13918 if (size_hooks > device_param->device_maxmem_alloc) skip = 1;
13919
13920 if (( bitmap_size
13921 + bitmap_size
13922 + bitmap_size
13923 + bitmap_size
13924 + bitmap_size
13925 + bitmap_size
13926 + bitmap_size
13927 + bitmap_size
13928 + size_bfs
13929 + size_combs
13930 + size_digests
13931 + size_esalts
13932 + size_hooks
13933 + size_markov_css
13934 + size_plains
13935 + size_pws
13936 + size_pws // not a bug
13937 + size_results
13938 + size_root_css
13939 + size_rules
13940 + size_rules_c
13941 + size_salts
13942 + size_scryptV
13943 + size_shown
13944 + size_tm
13945 + size_tmps) > device_param->device_global_mem) skip = 1;
13946
13947 if (skip == 1)
13948 {
13949 kernel_accel_max--;
13950
13951 continue;
13952 }
13953
13954 break;
13955 }
13956
13957 /*
13958 if (kernel_accel_max == 0)
13959 {
13960 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
13961
13962 return -1;
13963 }
13964 */
13965
13966 device_param->kernel_accel_min = kernel_accel_min;
13967 device_param->kernel_accel_max = kernel_accel_max;
13968
13969 /*
13970 if (kernel_accel_max < kernel_accel)
13971 {
13972 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
13973
13974 device_param->kernel_accel = kernel_accel_max;
13975 }
13976 */
13977
13978 device_param->size_bfs = size_bfs;
13979 device_param->size_combs = size_combs;
13980 device_param->size_rules = size_rules;
13981 device_param->size_rules_c = size_rules_c;
13982 device_param->size_pws = size_pws;
13983 device_param->size_tmps = size_tmps;
13984 device_param->size_hooks = size_hooks;
13985
13986 // do not confuse kernel_accel_max with kernel_accel here
13987
13988 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
13989
13990 device_param->kernel_threads = kernel_threads;
13991 device_param->kernel_power_user = kernel_power;
13992
13993 kernel_power_all += kernel_power;
13994
13995 /**
13996 * default building options
13997 */
13998
13999 char build_opts[1024] = { 0 };
14000
14001 // we don't have sm_* on vendors not NV but it doesn't matter
14002
14003 snprintf (build_opts, sizeof (build_opts) - 1, "-cl-std=CL1.1 -I\"%s/\" -DVENDOR_ID=%u -DCUDA_ARCH=%d -DVECT_SIZE=%u -DDEVICE_TYPE=%u -DKERN_TYPE=%u -D_unroll", shared_dir, device_param->vendor_id, (device_param->sm_major * 100) + device_param->sm_minor, device_param->vector_width, (u32) device_param->device_type, kern_type);
14004
14005 if (device_param->vendor_id == VENDOR_ID_INTEL_SDK)
14006 {
14007 // we do vectorizing much better than the auto-vectorizer
14008
14009 char build_opts_new[1024] = { 0 };
14010
14011 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -cl-opt-disable", build_opts);
14012
14013 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14014 }
14015
14016 #ifdef DEBUG
14017 log_info ("Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
14018 #endif
14019
14020 /**
14021 * main kernel
14022 */
14023
14024 {
14025 /**
14026 * kernel source filename
14027 */
14028
14029 char source_file[256] = { 0 };
14030
14031 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
14032
14033 struct stat sst;
14034
14035 if (stat (source_file, &sst) == -1)
14036 {
14037 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14038
14039 return -1;
14040 }
14041
14042 /**
14043 * kernel cached filename
14044 */
14045
14046 char cached_file[256] = { 0 };
14047
14048 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
14049
14050 int cached = 1;
14051
14052 struct stat cst;
14053
14054 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
14055 {
14056 cached = 0;
14057 }
14058
14059 /**
14060 * kernel compile or load
14061 */
14062
14063 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14064
14065 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14066
14067 if (force_jit_compilation == -1)
14068 {
14069 if (cached == 0)
14070 {
14071 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14072
14073 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14074
14075 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14076
14077 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
14078
14079 #ifdef DEBUG
14080 size_t build_log_size = 0;
14081
14082 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14083
14084 if (build_log_size > 1)
14085 {
14086 char *build_log = (char *) malloc (build_log_size + 1);
14087
14088 memset (build_log, 0, build_log_size + 1);
14089
14090 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14091
14092 puts (build_log);
14093
14094 free (build_log);
14095 }
14096 #endif
14097
14098 if (rc != 0)
14099 {
14100 device_param->skipped = true;
14101
14102 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14103
14104 continue;
14105 }
14106
14107 size_t binary_size;
14108
14109 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14110
14111 u8 *binary = (u8 *) mymalloc (binary_size);
14112
14113 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14114
14115 writeProgramBin (cached_file, binary, binary_size);
14116
14117 local_free (binary);
14118 }
14119 else
14120 {
14121 #ifdef DEBUG
14122 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14123 #endif
14124
14125 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14126
14127 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14128
14129 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
14130 }
14131 }
14132 else
14133 {
14134 #ifdef DEBUG
14135 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
14136 #endif
14137
14138 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14139
14140 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14141
14142 char build_opts_update[1024] = { 0 };
14143
14144 if (force_jit_compilation == 1500)
14145 {
14146 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
14147 }
14148 else if (force_jit_compilation == 8900)
14149 {
14150 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);
14151 }
14152 else
14153 {
14154 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
14155 }
14156
14157 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
14158
14159 #ifdef DEBUG
14160 size_t build_log_size = 0;
14161
14162 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14163
14164 if (build_log_size > 1)
14165 {
14166 char *build_log = (char *) malloc (build_log_size + 1);
14167
14168 memset (build_log, 0, build_log_size + 1);
14169
14170 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14171
14172 puts (build_log);
14173
14174 free (build_log);
14175 }
14176 #endif
14177
14178 if (rc != 0)
14179 {
14180 device_param->skipped = true;
14181
14182 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14183 }
14184 }
14185
14186 local_free (kernel_lengths);
14187 local_free (kernel_sources[0]);
14188 local_free (kernel_sources);
14189 }
14190
14191 /**
14192 * word generator kernel
14193 */
14194
14195 if (attack_mode != ATTACK_MODE_STRAIGHT)
14196 {
14197 /**
14198 * kernel mp source filename
14199 */
14200
14201 char source_file[256] = { 0 };
14202
14203 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
14204
14205 struct stat sst;
14206
14207 if (stat (source_file, &sst) == -1)
14208 {
14209 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14210
14211 return -1;
14212 }
14213
14214 /**
14215 * kernel mp cached filename
14216 */
14217
14218 char cached_file[256] = { 0 };
14219
14220 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
14221
14222 int cached = 1;
14223
14224 struct stat cst;
14225
14226 if (stat (cached_file, &cst) == -1)
14227 {
14228 cached = 0;
14229 }
14230
14231 /**
14232 * kernel compile or load
14233 */
14234
14235 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14236
14237 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14238
14239 if (cached == 0)
14240 {
14241 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14242 if (quiet == 0) log_info ("");
14243
14244 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14245
14246 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14247
14248 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
14249
14250 if (rc != 0)
14251 {
14252 device_param->skipped = true;
14253
14254 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14255
14256 continue;
14257 }
14258
14259 size_t binary_size;
14260
14261 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14262
14263 u8 *binary = (u8 *) mymalloc (binary_size);
14264
14265 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14266
14267 writeProgramBin (cached_file, binary, binary_size);
14268
14269 local_free (binary);
14270 }
14271 else
14272 {
14273 #ifdef DEBUG
14274 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14275 #endif
14276
14277 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14278
14279 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14280
14281 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
14282 }
14283
14284 local_free (kernel_lengths);
14285 local_free (kernel_sources[0]);
14286 local_free (kernel_sources);
14287 }
14288
14289 /**
14290 * amplifier kernel
14291 */
14292
14293 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14294 {
14295
14296 }
14297 else
14298 {
14299 /**
14300 * kernel amp source filename
14301 */
14302
14303 char source_file[256] = { 0 };
14304
14305 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
14306
14307 struct stat sst;
14308
14309 if (stat (source_file, &sst) == -1)
14310 {
14311 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14312
14313 return -1;
14314 }
14315
14316 /**
14317 * kernel amp cached filename
14318 */
14319
14320 char cached_file[256] = { 0 };
14321
14322 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
14323
14324 int cached = 1;
14325
14326 struct stat cst;
14327
14328 if (stat (cached_file, &cst) == -1)
14329 {
14330 cached = 0;
14331 }
14332
14333 /**
14334 * kernel compile or load
14335 */
14336
14337 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14338
14339 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14340
14341 if (cached == 0)
14342 {
14343 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14344 if (quiet == 0) log_info ("");
14345
14346 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14347
14348 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14349
14350 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
14351
14352 if (rc != 0)
14353 {
14354 device_param->skipped = true;
14355
14356 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14357
14358 continue;
14359 }
14360
14361 size_t binary_size;
14362
14363 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14364
14365 u8 *binary = (u8 *) mymalloc (binary_size);
14366
14367 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14368
14369 writeProgramBin (cached_file, binary, binary_size);
14370
14371 local_free (binary);
14372 }
14373 else
14374 {
14375 #ifdef DEBUG
14376 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14377 #endif
14378
14379 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14380
14381 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14382
14383 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
14384 }
14385
14386 local_free (kernel_lengths);
14387 local_free (kernel_sources[0]);
14388 local_free (kernel_sources);
14389 }
14390
14391 // some algorithm collide too fast, make that impossible
14392
14393 if (benchmark == 1)
14394 {
14395 ((uint *) digests_buf)[0] = -1;
14396 ((uint *) digests_buf)[1] = -1;
14397 ((uint *) digests_buf)[2] = -1;
14398 ((uint *) digests_buf)[3] = -1;
14399 }
14400
14401 /**
14402 * global buffers
14403 */
14404
14405 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14406 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14407 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
14408 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
14409 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14410 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14411 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14412 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14413 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14414 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14415 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14416 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14417 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
14418 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
14419 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
14420 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
14421 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
14422 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
14423
14424 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);
14425 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);
14426 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);
14427 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);
14428 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);
14429 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);
14430 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);
14431 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);
14432 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
14433 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
14434 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
14435
14436 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
14437 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
14438 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
14439 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
14440 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
14441 run_kernel_bzero (device_param, device_param->d_result, size_results);
14442
14443 /**
14444 * special buffers
14445 */
14446
14447 if (attack_kern == ATTACK_KERN_STRAIGHT)
14448 {
14449 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
14450 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
14451
14452 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
14453
14454 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
14455 }
14456 else if (attack_kern == ATTACK_KERN_COMBI)
14457 {
14458 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14459 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14460 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14461 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14462
14463 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
14464 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
14465 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14466 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14467 }
14468 else if (attack_kern == ATTACK_KERN_BF)
14469 {
14470 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14471 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14472 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
14473 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14474 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14475
14476 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
14477 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
14478 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
14479 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14480 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14481 }
14482
14483 if (size_esalts)
14484 {
14485 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
14486
14487 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
14488 }
14489
14490 /**
14491 * main host data
14492 */
14493
14494 uint *result = (uint *) mymalloc (size_results);
14495
14496 device_param->result = result;
14497
14498 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
14499
14500 device_param->pws_buf = pws_buf;
14501
14502 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
14503
14504 device_param->combs_buf = combs_buf;
14505
14506 void *hooks_buf = mymalloc (size_hooks);
14507
14508 device_param->hooks_buf = hooks_buf;
14509
14510 /**
14511 * kernel args
14512 */
14513
14514 device_param->kernel_params_buf32[21] = bitmap_mask;
14515 device_param->kernel_params_buf32[22] = bitmap_shift1;
14516 device_param->kernel_params_buf32[23] = bitmap_shift2;
14517 device_param->kernel_params_buf32[24] = 0; // salt_pos
14518 device_param->kernel_params_buf32[25] = 0; // loop_pos
14519 device_param->kernel_params_buf32[26] = 0; // loop_cnt
14520 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
14521 device_param->kernel_params_buf32[28] = 0; // digests_cnt
14522 device_param->kernel_params_buf32[29] = 0; // digests_offset
14523 device_param->kernel_params_buf32[30] = 0; // combs_mode
14524 device_param->kernel_params_buf32[31] = 0; // gid_max
14525
14526 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14527 ? &device_param->d_pws_buf
14528 : &device_param->d_pws_amp_buf;
14529 device_param->kernel_params[ 1] = &device_param->d_rules_c;
14530 device_param->kernel_params[ 2] = &device_param->d_combs_c;
14531 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
14532 device_param->kernel_params[ 4] = &device_param->d_tmps;
14533 device_param->kernel_params[ 5] = &device_param->d_hooks;
14534 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
14535 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
14536 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
14537 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
14538 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
14539 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
14540 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
14541 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
14542 device_param->kernel_params[14] = &device_param->d_plain_bufs;
14543 device_param->kernel_params[15] = &device_param->d_digests_buf;
14544 device_param->kernel_params[16] = &device_param->d_digests_shown;
14545 device_param->kernel_params[17] = &device_param->d_salt_bufs;
14546 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
14547 device_param->kernel_params[19] = &device_param->d_result;
14548 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
14549 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
14550 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
14551 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
14552 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
14553 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
14554 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
14555 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
14556 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
14557 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
14558 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
14559 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
14560
14561 device_param->kernel_params_mp_buf64[3] = 0;
14562 device_param->kernel_params_mp_buf32[4] = 0;
14563 device_param->kernel_params_mp_buf32[5] = 0;
14564 device_param->kernel_params_mp_buf32[6] = 0;
14565 device_param->kernel_params_mp_buf32[7] = 0;
14566 device_param->kernel_params_mp_buf32[8] = 0;
14567
14568 device_param->kernel_params_mp[0] = NULL;
14569 device_param->kernel_params_mp[1] = NULL;
14570 device_param->kernel_params_mp[2] = NULL;
14571 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
14572 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
14573 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
14574 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
14575 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
14576 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
14577
14578 device_param->kernel_params_mp_l_buf64[3] = 0;
14579 device_param->kernel_params_mp_l_buf32[4] = 0;
14580 device_param->kernel_params_mp_l_buf32[5] = 0;
14581 device_param->kernel_params_mp_l_buf32[6] = 0;
14582 device_param->kernel_params_mp_l_buf32[7] = 0;
14583 device_param->kernel_params_mp_l_buf32[8] = 0;
14584 device_param->kernel_params_mp_l_buf32[9] = 0;
14585
14586 device_param->kernel_params_mp_l[0] = NULL;
14587 device_param->kernel_params_mp_l[1] = NULL;
14588 device_param->kernel_params_mp_l[2] = NULL;
14589 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14590 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14591 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14592 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14593 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14594 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14595 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14596
14597 device_param->kernel_params_mp_r_buf64[3] = 0;
14598 device_param->kernel_params_mp_r_buf32[4] = 0;
14599 device_param->kernel_params_mp_r_buf32[5] = 0;
14600 device_param->kernel_params_mp_r_buf32[6] = 0;
14601 device_param->kernel_params_mp_r_buf32[7] = 0;
14602 device_param->kernel_params_mp_r_buf32[8] = 0;
14603
14604 device_param->kernel_params_mp_r[0] = NULL;
14605 device_param->kernel_params_mp_r[1] = NULL;
14606 device_param->kernel_params_mp_r[2] = NULL;
14607 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14608 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14609 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14610 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14611 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14612 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14613
14614 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14615 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14616
14617 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14618 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14619 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14620 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14621 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14622 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14623 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14624
14625 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14626 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14627
14628 /**
14629 * kernel name
14630 */
14631
14632 size_t kernel_wgs_tmp;
14633
14634 char kernel_name[64] = { 0 };
14635
14636 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14637 {
14638 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14639 {
14640 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14641
14642 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14643
14644 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14645
14646 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14647
14648 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14649
14650 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14651 }
14652 else
14653 {
14654 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14655
14656 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14657
14658 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14659
14660 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14661
14662 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14663
14664 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14665 }
14666
14667 if (data.attack_mode == ATTACK_MODE_BF)
14668 {
14669 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14670 {
14671 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14672
14673 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14674
14675 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel_tm, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
14676 }
14677 }
14678 }
14679 else
14680 {
14681 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14682
14683 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14684
14685 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14686
14687 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14688
14689 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14690
14691 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14692
14693 if (opts_type & OPTS_TYPE_HOOK12)
14694 {
14695 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14696
14697 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14698
14699 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel12, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
14700 }
14701
14702 if (opts_type & OPTS_TYPE_HOOK23)
14703 {
14704 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14705
14706 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14707
14708 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel23, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
14709 }
14710 }
14711
14712 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel1, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
14713 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel2, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
14714 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel3, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
14715
14716 for (uint i = 0; i <= 20; i++)
14717 {
14718 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14719 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14720 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14721
14722 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14723 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14724 }
14725
14726 for (uint i = 21; i <= 31; i++)
14727 {
14728 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14729 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14730 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14731
14732 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14733 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14734 }
14735
14736 if (attack_mode == ATTACK_MODE_BF)
14737 {
14738 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
14739 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
14740
14741 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel_mp_l, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
14742 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel_mp_r, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
14743
14744 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14745 {
14746 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14747 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14748 }
14749 }
14750 else if (attack_mode == ATTACK_MODE_HYBRID1)
14751 {
14752 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14753
14754 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel_mp, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
14755 }
14756 else if (attack_mode == ATTACK_MODE_HYBRID2)
14757 {
14758 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14759
14760 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel_mp, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
14761 }
14762
14763 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14764 {
14765 // nothing to do
14766 }
14767 else
14768 {
14769 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
14770
14771 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel_amp, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
14772 }
14773
14774 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14775 {
14776 // nothing to do
14777 }
14778 else
14779 {
14780 for (uint i = 0; i < 5; i++)
14781 {
14782 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14783 }
14784
14785 for (uint i = 5; i < 7; i++)
14786 {
14787 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14788 }
14789 }
14790
14791 // maybe this has been updated by clGetKernelWorkGroupInfo()
14792 // value can only be decreased, so we don't need to reallocate buffers
14793
14794 device_param->kernel_threads = kernel_threads;
14795
14796 /**
14797 * Store initial fanspeed if gpu_temp_retain is enabled
14798 */
14799
14800 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
14801 int gpu_temp_retain_set = 0;
14802
14803 if (gpu_temp_disable == 0)
14804 {
14805 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14806 {
14807 hc_thread_mutex_lock (mux_adl);
14808
14809 if (data.hm_device[device_id].fan_supported == 1)
14810 {
14811 if (gpu_temp_retain_chgd == 0)
14812 {
14813 uint cur_temp = 0;
14814 uint default_temp = 0;
14815
14816 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);
14817
14818 if (ADL_rc == ADL_OK)
14819 {
14820 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14821
14822 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14823
14824 // special case with multi gpu setups: always use minimum retain
14825
14826 if (gpu_temp_retain_set == 0)
14827 {
14828 gpu_temp_retain = gpu_temp_retain_target;
14829 gpu_temp_retain_set = 1;
14830 }
14831 else
14832 {
14833 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14834 }
14835
14836 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14837 }
14838 }
14839
14840 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14841
14842 temp_retain_fanspeed_value[device_id] = fan_speed;
14843
14844 if (fan_speed == -1)
14845 {
14846 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14847
14848 temp_retain_fanspeed_value[device_id] = 0;
14849 }
14850 }
14851
14852 hc_thread_mutex_unlock (mux_adl);
14853 }
14854 }
14855
14856 /**
14857 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14858 */
14859
14860 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14861 {
14862 hc_thread_mutex_lock (mux_adl);
14863
14864 if (data.hm_device[device_id].od_version == 6)
14865 {
14866 int ADL_rc;
14867
14868 // check powertune capabilities first, if not available then skip device
14869
14870 int powertune_supported = 0;
14871
14872 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14873 {
14874 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14875
14876 return (-1);
14877 }
14878
14879 if (powertune_supported != 0)
14880 {
14881 // powercontrol settings
14882
14883 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14884
14885 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14886 {
14887 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14888 }
14889
14890 if (ADL_rc != ADL_OK)
14891 {
14892 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14893
14894 return (-1);
14895 }
14896
14897 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14898 {
14899 log_error ("ERROR: Failed to set new ADL PowerControl values");
14900
14901 return (-1);
14902 }
14903
14904 // clocks
14905
14906 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14907
14908 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14909
14910 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)
14911 {
14912 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14913
14914 return (-1);
14915 }
14916
14917 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14918
14919 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14920
14921 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14922 {
14923 log_error ("ERROR: Failed to get ADL device capabilities");
14924
14925 return (-1);
14926 }
14927
14928 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14929 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14930
14931 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14932 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14933
14934 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14935 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14936
14937 // warning if profile has too low max values
14938
14939 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14940 {
14941 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14942 }
14943
14944 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14945 {
14946 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14947 }
14948
14949 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14950
14951 performance_state->iNumberOfPerformanceLevels = 2;
14952
14953 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14954 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14955 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14956 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14957
14958 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)
14959 {
14960 log_info ("ERROR: Failed to set ADL performance state");
14961
14962 return (-1);
14963 }
14964
14965 local_free (performance_state);
14966 }
14967 }
14968
14969 hc_thread_mutex_unlock (mux_adl);
14970 }
14971 #endif // HAVE_HWMON && HAVE_ADL
14972 }
14973
14974 data.kernel_power_all = kernel_power_all;
14975
14976 if (data.quiet == 0) log_info_nn ("");
14977
14978 /**
14979 * In benchmark-mode, inform user which algorithm is checked
14980 */
14981
14982 if (benchmark == 1)
14983 {
14984 quiet = 0;
14985
14986 data.quiet = quiet;
14987
14988 char *hash_type = strhashtype (data.hash_mode); // not a bug
14989
14990 log_info ("Hashtype: %s", hash_type);
14991 log_info ("");
14992 }
14993
14994 /**
14995 * keep track of the progress
14996 */
14997
14998 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14999 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15000 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15001
15002 /**
15003 * open filehandles
15004 */
15005
15006 #if _WIN
15007 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
15008 {
15009 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
15010
15011 return (-1);
15012 }
15013
15014 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
15015 {
15016 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
15017
15018 return (-1);
15019 }
15020
15021 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
15022 {
15023 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
15024
15025 return (-1);
15026 }
15027 #endif
15028
15029 /**
15030 * dictionary pad
15031 */
15032
15033 segment_size *= (1024 * 1024);
15034
15035 data.segment_size = segment_size;
15036
15037 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
15038
15039 wl_data->buf = (char *) mymalloc (segment_size);
15040 wl_data->avail = segment_size;
15041 wl_data->incr = segment_size;
15042 wl_data->cnt = 0;
15043 wl_data->pos = 0;
15044
15045 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
15046
15047 data.wordlist_mode = wordlist_mode;
15048
15049 cs_t *css_buf = NULL;
15050 uint css_cnt = 0;
15051 uint dictcnt = 0;
15052 uint maskcnt = 1;
15053 char **masks = NULL;
15054 char **dictfiles = NULL;
15055
15056 uint mask_from_file = 0;
15057
15058 if (attack_mode == ATTACK_MODE_STRAIGHT)
15059 {
15060 if (wordlist_mode == WL_MODE_FILE)
15061 {
15062 int wls_left = myargc - (optind + 1);
15063
15064 for (int i = 0; i < wls_left; i++)
15065 {
15066 char *l0_filename = myargv[optind + 1 + i];
15067
15068 struct stat l0_stat;
15069
15070 if (stat (l0_filename, &l0_stat) == -1)
15071 {
15072 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
15073
15074 return (-1);
15075 }
15076
15077 uint is_dir = S_ISDIR (l0_stat.st_mode);
15078
15079 if (is_dir == 0)
15080 {
15081 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15082
15083 dictcnt++;
15084
15085 dictfiles[dictcnt - 1] = l0_filename;
15086 }
15087 else
15088 {
15089 // do not allow --keyspace w/ a directory
15090
15091 if (keyspace == 1)
15092 {
15093 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15094
15095 return (-1);
15096 }
15097
15098 char **dictionary_files = NULL;
15099
15100 dictionary_files = scan_directory (l0_filename);
15101
15102 if (dictionary_files != NULL)
15103 {
15104 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15105
15106 for (int d = 0; dictionary_files[d] != NULL; d++)
15107 {
15108 char *l1_filename = dictionary_files[d];
15109
15110 struct stat l1_stat;
15111
15112 if (stat (l1_filename, &l1_stat) == -1)
15113 {
15114 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15115
15116 return (-1);
15117 }
15118
15119 if (S_ISREG (l1_stat.st_mode))
15120 {
15121 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15122
15123 dictcnt++;
15124
15125 dictfiles[dictcnt - 1] = strdup (l1_filename);
15126 }
15127 }
15128 }
15129
15130 local_free (dictionary_files);
15131 }
15132 }
15133
15134 if (dictcnt < 1)
15135 {
15136 log_error ("ERROR: No usable dictionary file found.");
15137
15138 return (-1);
15139 }
15140 }
15141 else if (wordlist_mode == WL_MODE_STDIN)
15142 {
15143 dictcnt = 1;
15144 }
15145 }
15146 else if (attack_mode == ATTACK_MODE_COMBI)
15147 {
15148 // display
15149
15150 char *dictfile1 = myargv[optind + 1 + 0];
15151 char *dictfile2 = myargv[optind + 1 + 1];
15152
15153 // find the bigger dictionary and use as base
15154
15155 FILE *fp1 = NULL;
15156 FILE *fp2 = NULL;
15157
15158 struct stat tmp_stat;
15159
15160 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
15161 {
15162 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15163
15164 return (-1);
15165 }
15166
15167 if (stat (dictfile1, &tmp_stat) == -1)
15168 {
15169 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15170
15171 fclose (fp1);
15172
15173 return (-1);
15174 }
15175
15176 if (S_ISDIR (tmp_stat.st_mode))
15177 {
15178 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
15179
15180 fclose (fp1);
15181
15182 return (-1);
15183 }
15184
15185 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
15186 {
15187 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15188
15189 fclose (fp1);
15190
15191 return (-1);
15192 }
15193
15194 if (stat (dictfile2, &tmp_stat) == -1)
15195 {
15196 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15197
15198 fclose (fp1);
15199 fclose (fp2);
15200
15201 return (-1);
15202 }
15203
15204 if (S_ISDIR (tmp_stat.st_mode))
15205 {
15206 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
15207
15208 fclose (fp1);
15209 fclose (fp2);
15210
15211 return (-1);
15212 }
15213
15214 data.combs_cnt = 1;
15215
15216 data.quiet = 1;
15217
15218 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
15219
15220 data.quiet = quiet;
15221
15222 if (words1_cnt == 0)
15223 {
15224 log_error ("ERROR: %s: empty file", dictfile1);
15225
15226 fclose (fp1);
15227 fclose (fp2);
15228
15229 return (-1);
15230 }
15231
15232 data.combs_cnt = 1;
15233
15234 data.quiet = 1;
15235
15236 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
15237
15238 data.quiet = quiet;
15239
15240 if (words2_cnt == 0)
15241 {
15242 log_error ("ERROR: %s: empty file", dictfile2);
15243
15244 fclose (fp1);
15245 fclose (fp2);
15246
15247 return (-1);
15248 }
15249
15250 fclose (fp1);
15251 fclose (fp2);
15252
15253 data.dictfile = dictfile1;
15254 data.dictfile2 = dictfile2;
15255
15256 if (words1_cnt >= words2_cnt)
15257 {
15258 data.combs_cnt = words2_cnt;
15259 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15260
15261 dictfiles = &data.dictfile;
15262
15263 dictcnt = 1;
15264 }
15265 else
15266 {
15267 data.combs_cnt = words1_cnt;
15268 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15269
15270 dictfiles = &data.dictfile2;
15271
15272 dictcnt = 1;
15273
15274 // we also have to switch wordlist related rules!
15275
15276 char *tmpc = data.rule_buf_l;
15277
15278 data.rule_buf_l = data.rule_buf_r;
15279 data.rule_buf_r = tmpc;
15280
15281 int tmpi = data.rule_len_l;
15282
15283 data.rule_len_l = data.rule_len_r;
15284 data.rule_len_r = tmpi;
15285 }
15286 }
15287 else if (attack_mode == ATTACK_MODE_BF)
15288 {
15289 char *mask = NULL;
15290
15291 maskcnt = 0;
15292
15293 if (benchmark == 0)
15294 {
15295 mask = myargv[optind + 1];
15296
15297 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
15298
15299 if ((optind + 2) <= myargc)
15300 {
15301 struct stat file_stat;
15302
15303 if (stat (mask, &file_stat) == -1)
15304 {
15305 maskcnt = 1;
15306
15307 masks[maskcnt - 1] = mystrdup (mask);
15308 }
15309 else
15310 {
15311 int wls_left = myargc - (optind + 1);
15312
15313 uint masks_avail = INCR_MASKS;
15314
15315 for (int i = 0; i < wls_left; i++)
15316 {
15317 if (i != 0)
15318 {
15319 mask = myargv[optind + 1 + i];
15320
15321 if (stat (mask, &file_stat) == -1)
15322 {
15323 log_error ("ERROR: %s: %s", mask, strerror (errno));
15324
15325 return (-1);
15326 }
15327 }
15328
15329 uint is_file = S_ISREG (file_stat.st_mode);
15330
15331 if (is_file == 1)
15332 {
15333 FILE *mask_fp;
15334
15335 if ((mask_fp = fopen (mask, "r")) == NULL)
15336 {
15337 log_error ("ERROR: %s: %s", mask, strerror (errno));
15338
15339 return (-1);
15340 }
15341
15342 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15343
15344 while (!feof (mask_fp))
15345 {
15346 memset (line_buf, 0, HCBUFSIZ);
15347
15348 int line_len = fgetl (mask_fp, line_buf);
15349
15350 if (line_len == 0) continue;
15351
15352 if (line_buf[0] == '#') continue;
15353
15354 if (masks_avail == maskcnt)
15355 {
15356 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15357
15358 masks_avail += INCR_MASKS;
15359 }
15360
15361 masks[maskcnt] = mystrdup (line_buf);
15362
15363 maskcnt++;
15364 }
15365
15366 myfree (line_buf);
15367
15368 fclose (mask_fp);
15369 }
15370 else
15371 {
15372 log_error ("ERROR: %s: unsupported file-type", mask);
15373
15374 return (-1);
15375 }
15376 }
15377
15378 mask_from_file = 1;
15379 }
15380 }
15381 else
15382 {
15383 custom_charset_1 = (char *) "?l?d?u";
15384 custom_charset_2 = (char *) "?l?d";
15385 custom_charset_3 = (char *) "?l?d*!$@_";
15386
15387 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15388 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15389 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15390
15391 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
15392
15393 wordlist_mode = WL_MODE_MASK;
15394
15395 data.wordlist_mode = wordlist_mode;
15396
15397 increment = 1;
15398
15399 maskcnt = 1;
15400 }
15401 }
15402 else
15403 {
15404 /**
15405 * generate full masks and charsets
15406 */
15407
15408 masks = (char **) mymalloc (sizeof (char *));
15409
15410 switch (hash_mode)
15411 {
15412 case 1731: pw_min = 5;
15413 pw_max = 5;
15414 mask = mystrdup ("?b?b?b?b?b");
15415 break;
15416 case 12500: pw_min = 5;
15417 pw_max = 5;
15418 mask = mystrdup ("?b?b?b?b?b");
15419 break;
15420 default: pw_min = 7;
15421 pw_max = 7;
15422 mask = mystrdup ("?b?b?b?b?b?b?b");
15423 break;
15424 }
15425
15426 maskcnt = 1;
15427
15428 masks[maskcnt - 1] = mystrdup (mask);
15429
15430 wordlist_mode = WL_MODE_MASK;
15431
15432 data.wordlist_mode = wordlist_mode;
15433
15434 increment = 1;
15435 }
15436
15437 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
15438
15439 if (increment)
15440 {
15441 if (increment_min > pw_min) pw_min = increment_min;
15442
15443 if (increment_max < pw_max) pw_max = increment_max;
15444 }
15445 }
15446 else if (attack_mode == ATTACK_MODE_HYBRID1)
15447 {
15448 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15449
15450 // display
15451
15452 char *mask = myargv[myargc - 1];
15453
15454 maskcnt = 0;
15455
15456 masks = (char **) mymalloc (1 * sizeof (char *));
15457
15458 // mod
15459
15460 struct stat file_stat;
15461
15462 if (stat (mask, &file_stat) == -1)
15463 {
15464 maskcnt = 1;
15465
15466 masks[maskcnt - 1] = mystrdup (mask);
15467 }
15468 else
15469 {
15470 uint is_file = S_ISREG (file_stat.st_mode);
15471
15472 if (is_file == 1)
15473 {
15474 FILE *mask_fp;
15475
15476 if ((mask_fp = fopen (mask, "r")) == NULL)
15477 {
15478 log_error ("ERROR: %s: %s", mask, strerror (errno));
15479
15480 return (-1);
15481 }
15482
15483 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15484
15485 uint masks_avail = 1;
15486
15487 while (!feof (mask_fp))
15488 {
15489 memset (line_buf, 0, HCBUFSIZ);
15490
15491 int line_len = fgetl (mask_fp, line_buf);
15492
15493 if (line_len == 0) continue;
15494
15495 if (line_buf[0] == '#') continue;
15496
15497 if (masks_avail == maskcnt)
15498 {
15499 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15500
15501 masks_avail += INCR_MASKS;
15502 }
15503
15504 masks[maskcnt] = mystrdup (line_buf);
15505
15506 maskcnt++;
15507 }
15508
15509 myfree (line_buf);
15510
15511 fclose (mask_fp);
15512
15513 mask_from_file = 1;
15514 }
15515 else
15516 {
15517 maskcnt = 1;
15518
15519 masks[maskcnt - 1] = mystrdup (mask);
15520 }
15521 }
15522
15523 // base
15524
15525 int wls_left = myargc - (optind + 2);
15526
15527 for (int i = 0; i < wls_left; i++)
15528 {
15529 char *filename = myargv[optind + 1 + i];
15530
15531 struct stat file_stat;
15532
15533 if (stat (filename, &file_stat) == -1)
15534 {
15535 log_error ("ERROR: %s: %s", filename, strerror (errno));
15536
15537 return (-1);
15538 }
15539
15540 uint is_dir = S_ISDIR (file_stat.st_mode);
15541
15542 if (is_dir == 0)
15543 {
15544 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15545
15546 dictcnt++;
15547
15548 dictfiles[dictcnt - 1] = filename;
15549 }
15550 else
15551 {
15552 // do not allow --keyspace w/ a directory
15553
15554 if (keyspace == 1)
15555 {
15556 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15557
15558 return (-1);
15559 }
15560
15561 char **dictionary_files = NULL;
15562
15563 dictionary_files = scan_directory (filename);
15564
15565 if (dictionary_files != NULL)
15566 {
15567 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15568
15569 for (int d = 0; dictionary_files[d] != NULL; d++)
15570 {
15571 char *l1_filename = dictionary_files[d];
15572
15573 struct stat l1_stat;
15574
15575 if (stat (l1_filename, &l1_stat) == -1)
15576 {
15577 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15578
15579 return (-1);
15580 }
15581
15582 if (S_ISREG (l1_stat.st_mode))
15583 {
15584 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15585
15586 dictcnt++;
15587
15588 dictfiles[dictcnt - 1] = strdup (l1_filename);
15589 }
15590 }
15591 }
15592
15593 local_free (dictionary_files);
15594 }
15595 }
15596
15597 if (dictcnt < 1)
15598 {
15599 log_error ("ERROR: No usable dictionary file found.");
15600
15601 return (-1);
15602 }
15603
15604 if (increment)
15605 {
15606 maskcnt = 0;
15607
15608 uint mask_min = increment_min; // we can't reject smaller masks here
15609 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15610
15611 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15612 {
15613 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15614
15615 if (cur_mask == NULL) break;
15616
15617 masks[maskcnt] = cur_mask;
15618
15619 maskcnt++;
15620
15621 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15622 }
15623 }
15624 }
15625 else if (attack_mode == ATTACK_MODE_HYBRID2)
15626 {
15627 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15628
15629 // display
15630
15631 char *mask = myargv[optind + 1 + 0];
15632
15633 maskcnt = 0;
15634
15635 masks = (char **) mymalloc (1 * sizeof (char *));
15636
15637 // mod
15638
15639 struct stat file_stat;
15640
15641 if (stat (mask, &file_stat) == -1)
15642 {
15643 maskcnt = 1;
15644
15645 masks[maskcnt - 1] = mystrdup (mask);
15646 }
15647 else
15648 {
15649 uint is_file = S_ISREG (file_stat.st_mode);
15650
15651 if (is_file == 1)
15652 {
15653 FILE *mask_fp;
15654
15655 if ((mask_fp = fopen (mask, "r")) == NULL)
15656 {
15657 log_error ("ERROR: %s: %s", mask, strerror (errno));
15658
15659 return (-1);
15660 }
15661
15662 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15663
15664 uint masks_avail = 1;
15665
15666 while (!feof (mask_fp))
15667 {
15668 memset (line_buf, 0, HCBUFSIZ);
15669
15670 int line_len = fgetl (mask_fp, line_buf);
15671
15672 if (line_len == 0) continue;
15673
15674 if (line_buf[0] == '#') continue;
15675
15676 if (masks_avail == maskcnt)
15677 {
15678 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15679
15680 masks_avail += INCR_MASKS;
15681 }
15682
15683 masks[maskcnt] = mystrdup (line_buf);
15684
15685 maskcnt++;
15686 }
15687
15688 myfree (line_buf);
15689
15690 fclose (mask_fp);
15691
15692 mask_from_file = 1;
15693 }
15694 else
15695 {
15696 maskcnt = 1;
15697
15698 masks[maskcnt - 1] = mystrdup (mask);
15699 }
15700 }
15701
15702 // base
15703
15704 int wls_left = myargc - (optind + 2);
15705
15706 for (int i = 0; i < wls_left; i++)
15707 {
15708 char *filename = myargv[optind + 2 + i];
15709
15710 struct stat file_stat;
15711
15712 if (stat (filename, &file_stat) == -1)
15713 {
15714 log_error ("ERROR: %s: %s", filename, strerror (errno));
15715
15716 return (-1);
15717 }
15718
15719 uint is_dir = S_ISDIR (file_stat.st_mode);
15720
15721 if (is_dir == 0)
15722 {
15723 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15724
15725 dictcnt++;
15726
15727 dictfiles[dictcnt - 1] = filename;
15728 }
15729 else
15730 {
15731 // do not allow --keyspace w/ a directory
15732
15733 if (keyspace == 1)
15734 {
15735 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15736
15737 return (-1);
15738 }
15739
15740 char **dictionary_files = NULL;
15741
15742 dictionary_files = scan_directory (filename);
15743
15744 if (dictionary_files != NULL)
15745 {
15746 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15747
15748 for (int d = 0; dictionary_files[d] != NULL; d++)
15749 {
15750 char *l1_filename = dictionary_files[d];
15751
15752 struct stat l1_stat;
15753
15754 if (stat (l1_filename, &l1_stat) == -1)
15755 {
15756 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15757
15758 return (-1);
15759 }
15760
15761 if (S_ISREG (l1_stat.st_mode))
15762 {
15763 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15764
15765 dictcnt++;
15766
15767 dictfiles[dictcnt - 1] = strdup (l1_filename);
15768 }
15769 }
15770 }
15771
15772 local_free (dictionary_files);
15773 }
15774 }
15775
15776 if (dictcnt < 1)
15777 {
15778 log_error ("ERROR: No usable dictionary file found.");
15779
15780 return (-1);
15781 }
15782
15783 if (increment)
15784 {
15785 maskcnt = 0;
15786
15787 uint mask_min = increment_min; // we can't reject smaller masks here
15788 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15789
15790 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15791 {
15792 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15793
15794 if (cur_mask == NULL) break;
15795
15796 masks[maskcnt] = cur_mask;
15797
15798 maskcnt++;
15799
15800 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15801 }
15802 }
15803 }
15804
15805 data.pw_min = pw_min;
15806 data.pw_max = pw_max;
15807
15808 /**
15809 * weak hash check
15810 */
15811
15812 if (weak_hash_threshold >= salts_cnt)
15813 {
15814 hc_device_param_t *device_param = NULL;
15815
15816 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15817 {
15818 device_param = &data.devices_param[device_id];
15819
15820 if (device_param->skipped) continue;
15821
15822 break;
15823 }
15824
15825 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15826
15827 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15828 {
15829 weak_hash_check (device_param, salt_pos);
15830 }
15831
15832 // Display hack, guarantee that there is at least one \r before real start
15833
15834 //if (data.quiet == 0) log_info ("");
15835 }
15836
15837 /**
15838 * status and monitor threads
15839 */
15840
15841 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15842
15843 hc_thread_t i_thread = 0;
15844
15845 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15846 {
15847 hc_thread_create (i_thread, thread_keypress, &benchmark);
15848 }
15849
15850 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15851
15852 uint ni_threads_cnt = 0;
15853
15854 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15855
15856 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15857
15858 ni_threads_cnt++;
15859
15860 /**
15861 * Outfile remove
15862 */
15863
15864 if (keyspace == 0)
15865 {
15866 if (outfile_check_timer != 0)
15867 {
15868 if (data.outfile_check_directory != NULL)
15869 {
15870 if ((hash_mode != 5200) &&
15871 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15872 (hash_mode != 9000))
15873 {
15874 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15875
15876 ni_threads_cnt++;
15877 }
15878 else
15879 {
15880 outfile_check_timer = 0;
15881 }
15882 }
15883 else
15884 {
15885 outfile_check_timer = 0;
15886 }
15887 }
15888 }
15889
15890 /**
15891 * Inform the user if we got some hashes remove because of the pot file remove feature
15892 */
15893
15894 if (data.quiet == 0)
15895 {
15896 if (potfile_remove_cracks > 0)
15897 {
15898 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15899 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15900 }
15901 }
15902
15903 data.outfile_check_timer = outfile_check_timer;
15904
15905 /**
15906 * main loop
15907 */
15908
15909 char **induction_dictionaries = NULL;
15910
15911 int induction_dictionaries_cnt = 0;
15912
15913 hcstat_table_t *root_table_buf = NULL;
15914 hcstat_table_t *markov_table_buf = NULL;
15915
15916 uint initial_restore_done = 0;
15917
15918 data.maskcnt = maskcnt;
15919
15920 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15921 {
15922 if (data.devices_status == STATUS_CRACKED) break;
15923
15924 data.devices_status = STATUS_INIT;
15925
15926 if (maskpos > rd->maskpos)
15927 {
15928 rd->dictpos = 0;
15929 }
15930
15931 rd->maskpos = maskpos;
15932 data.maskpos = maskpos;
15933
15934 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15935 {
15936 char *mask = masks[maskpos];
15937
15938 if (mask_from_file == 1)
15939 {
15940 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15941
15942 char *str_ptr;
15943 uint str_pos;
15944
15945 uint mask_offset = 0;
15946
15947 uint separator_cnt;
15948
15949 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15950 {
15951 str_ptr = strstr (mask + mask_offset, ",");
15952
15953 if (str_ptr == NULL) break;
15954
15955 str_pos = str_ptr - mask;
15956
15957 // escaped separator, i.e. "\,"
15958
15959 if (str_pos > 0)
15960 {
15961 if (mask[str_pos - 1] == '\\')
15962 {
15963 separator_cnt --;
15964
15965 mask_offset = str_pos + 1;
15966
15967 continue;
15968 }
15969 }
15970
15971 // reset the offset
15972
15973 mask_offset = 0;
15974
15975 mask[str_pos] = '\0';
15976
15977 switch (separator_cnt)
15978 {
15979 case 0:
15980 mp_reset_usr (mp_usr, 0);
15981
15982 custom_charset_1 = mask;
15983 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15984 break;
15985
15986 case 1:
15987 mp_reset_usr (mp_usr, 1);
15988
15989 custom_charset_2 = mask;
15990 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15991 break;
15992
15993 case 2:
15994 mp_reset_usr (mp_usr, 2);
15995
15996 custom_charset_3 = mask;
15997 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15998 break;
15999
16000 case 3:
16001 mp_reset_usr (mp_usr, 3);
16002
16003 custom_charset_4 = mask;
16004 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
16005 break;
16006 }
16007
16008 mask = mask + str_pos + 1;
16009 }
16010 }
16011
16012 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16013 {
16014 if (maskpos > 0)
16015 {
16016 local_free (css_buf);
16017 local_free (data.root_css_buf);
16018 local_free (data.markov_css_buf);
16019
16020 local_free (masks[maskpos - 1]);
16021 }
16022
16023 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16024
16025 data.mask = mask;
16026 data.css_cnt = css_cnt;
16027 data.css_buf = css_buf;
16028
16029 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16030
16031 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16032
16033 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16034 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16035
16036 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16037
16038 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16039
16040 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16041 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16042
16043 data.root_css_buf = root_css_buf;
16044 data.markov_css_buf = markov_css_buf;
16045
16046 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16047
16048 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16049
16050 local_free (root_table_buf);
16051 local_free (markov_table_buf);
16052
16053 // args
16054
16055 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16056 {
16057 hc_device_param_t *device_param = &data.devices_param[device_id];
16058
16059 if (device_param->skipped) continue;
16060
16061 device_param->kernel_params_mp[0] = &device_param->d_combs;
16062 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
16063 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
16064
16065 device_param->kernel_params_mp_buf64[3] = 0;
16066 device_param->kernel_params_mp_buf32[4] = css_cnt;
16067 device_param->kernel_params_mp_buf32[5] = 0;
16068 device_param->kernel_params_mp_buf32[6] = 0;
16069 device_param->kernel_params_mp_buf32[7] = 0;
16070
16071 if (attack_mode == ATTACK_MODE_HYBRID1)
16072 {
16073 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
16074 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
16075 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
16076 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
16077 }
16078 else if (attack_mode == ATTACK_MODE_HYBRID2)
16079 {
16080 device_param->kernel_params_mp_buf32[5] = 0;
16081 device_param->kernel_params_mp_buf32[6] = 0;
16082 device_param->kernel_params_mp_buf32[7] = 0;
16083 }
16084
16085 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]);
16086 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]);
16087 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]);
16088
16089 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);
16090 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);
16091 }
16092 }
16093 else if (attack_mode == ATTACK_MODE_BF)
16094 {
16095 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
16096
16097 if (increment)
16098 {
16099 for (uint i = 0; i < dictcnt; i++)
16100 {
16101 local_free (dictfiles[i]);
16102 }
16103
16104 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
16105 {
16106 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
16107
16108 if (l1_filename == NULL) break;
16109
16110 dictcnt++;
16111
16112 dictfiles[dictcnt - 1] = l1_filename;
16113 }
16114 }
16115 else
16116 {
16117 dictcnt++;
16118
16119 dictfiles[dictcnt - 1] = mask;
16120 }
16121
16122 if (dictcnt == 0)
16123 {
16124 log_error ("ERROR: Mask is too small");
16125
16126 return (-1);
16127 }
16128 }
16129 }
16130
16131 free (induction_dictionaries);
16132
16133 // induction_dictionaries_cnt = 0; // implied
16134
16135 if (attack_mode != ATTACK_MODE_BF)
16136 {
16137 if (keyspace == 0)
16138 {
16139 induction_dictionaries = scan_directory (induction_directory);
16140
16141 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16142 }
16143 }
16144
16145 if (induction_dictionaries_cnt)
16146 {
16147 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16148 }
16149
16150 /**
16151 * prevent the user from using --keyspace together w/ maskfile and or dictfile
16152 */
16153 if (keyspace == 1)
16154 {
16155 if ((maskcnt > 1) || (dictcnt > 1))
16156 {
16157 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
16158
16159 return (-1);
16160 }
16161 }
16162
16163 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
16164 {
16165 char *subid = logfile_generate_subid ();
16166
16167 data.subid = subid;
16168
16169 logfile_sub_msg ("START");
16170
16171 data.devices_status = STATUS_INIT;
16172
16173 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
16174 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
16175 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
16176
16177 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
16178
16179 data.cpt_pos = 0;
16180
16181 data.cpt_start = time (NULL);
16182
16183 data.cpt_total = 0;
16184
16185 if (data.restore == 0)
16186 {
16187 rd->words_cur = skip;
16188
16189 skip = 0;
16190
16191 data.skip = 0;
16192 }
16193
16194 data.ms_paused = 0;
16195
16196 data.words_cur = rd->words_cur;
16197
16198 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16199 {
16200 hc_device_param_t *device_param = &data.devices_param[device_id];
16201
16202 if (device_param->skipped) continue;
16203
16204 device_param->speed_pos = 0;
16205
16206 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
16207 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
16208
16209 device_param->exec_pos = 0;
16210
16211 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
16212
16213 device_param->kernel_power = device_param->kernel_power_user;
16214
16215 device_param->outerloop_pos = 0;
16216 device_param->outerloop_left = 0;
16217 device_param->innerloop_pos = 0;
16218 device_param->innerloop_left = 0;
16219
16220 // some more resets:
16221
16222 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
16223
16224 device_param->pws_cnt = 0;
16225
16226 device_param->words_off = 0;
16227 device_param->words_done = 0;
16228 }
16229
16230 data.kernel_power_div = 0;
16231
16232 // figure out some workload
16233
16234 if (attack_mode == ATTACK_MODE_STRAIGHT)
16235 {
16236 if (data.wordlist_mode == WL_MODE_FILE)
16237 {
16238 char *dictfile = NULL;
16239
16240 if (induction_dictionaries_cnt)
16241 {
16242 dictfile = induction_dictionaries[0];
16243 }
16244 else
16245 {
16246 dictfile = dictfiles[dictpos];
16247 }
16248
16249 data.dictfile = dictfile;
16250
16251 logfile_sub_string (dictfile);
16252
16253 for (uint i = 0; i < rp_files_cnt; i++)
16254 {
16255 logfile_sub_var_string ("rulefile", rp_files[i]);
16256 }
16257
16258 FILE *fd2 = fopen (dictfile, "rb");
16259
16260 if (fd2 == NULL)
16261 {
16262 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16263
16264 return (-1);
16265 }
16266
16267 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16268
16269 fclose (fd2);
16270
16271 if (data.words_cnt == 0)
16272 {
16273 if (data.devices_status == STATUS_CRACKED) break;
16274 if (data.devices_status == STATUS_ABORTED) break;
16275
16276 dictpos++;
16277
16278 continue;
16279 }
16280 }
16281 }
16282 else if (attack_mode == ATTACK_MODE_COMBI)
16283 {
16284 char *dictfile = data.dictfile;
16285 char *dictfile2 = data.dictfile2;
16286
16287 logfile_sub_string (dictfile);
16288 logfile_sub_string (dictfile2);
16289
16290 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
16291 {
16292 FILE *fd2 = fopen (dictfile, "rb");
16293
16294 if (fd2 == NULL)
16295 {
16296 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16297
16298 return (-1);
16299 }
16300
16301 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16302
16303 fclose (fd2);
16304 }
16305 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
16306 {
16307 FILE *fd2 = fopen (dictfile2, "rb");
16308
16309 if (fd2 == NULL)
16310 {
16311 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16312
16313 return (-1);
16314 }
16315
16316 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
16317
16318 fclose (fd2);
16319 }
16320
16321 if (data.words_cnt == 0)
16322 {
16323 if (data.devices_status == STATUS_CRACKED) break;
16324 if (data.devices_status == STATUS_ABORTED) break;
16325
16326 dictpos++;
16327
16328 continue;
16329 }
16330 }
16331 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16332 {
16333 char *dictfile = NULL;
16334
16335 if (induction_dictionaries_cnt)
16336 {
16337 dictfile = induction_dictionaries[0];
16338 }
16339 else
16340 {
16341 dictfile = dictfiles[dictpos];
16342 }
16343
16344 data.dictfile = dictfile;
16345
16346 char *mask = data.mask;
16347
16348 logfile_sub_string (dictfile);
16349 logfile_sub_string (mask);
16350
16351 FILE *fd2 = fopen (dictfile, "rb");
16352
16353 if (fd2 == NULL)
16354 {
16355 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16356
16357 return (-1);
16358 }
16359
16360 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16361
16362 fclose (fd2);
16363
16364 if (data.words_cnt == 0)
16365 {
16366 if (data.devices_status == STATUS_CRACKED) break;
16367 if (data.devices_status == STATUS_ABORTED) break;
16368
16369 dictpos++;
16370
16371 continue;
16372 }
16373 }
16374 else if (attack_mode == ATTACK_MODE_BF)
16375 {
16376 local_free (css_buf);
16377 local_free (data.root_css_buf);
16378 local_free (data.markov_css_buf);
16379
16380 char *mask = dictfiles[dictpos];
16381
16382 logfile_sub_string (mask);
16383
16384 // base
16385
16386 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16387
16388 if (opts_type & OPTS_TYPE_PT_UNICODE)
16389 {
16390 uint css_cnt_unicode = css_cnt * 2;
16391
16392 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
16393
16394 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
16395 {
16396 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
16397
16398 css_buf_unicode[j + 1].cs_buf[0] = 0;
16399 css_buf_unicode[j + 1].cs_len = 1;
16400 }
16401
16402 free (css_buf);
16403
16404 css_buf = css_buf_unicode;
16405 css_cnt = css_cnt_unicode;
16406 }
16407
16408 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
16409
16410 uint mask_min = pw_min;
16411 uint mask_max = pw_max;
16412
16413 if (opts_type & OPTS_TYPE_PT_UNICODE)
16414 {
16415 mask_min *= 2;
16416 mask_max *= 2;
16417 }
16418
16419 if ((css_cnt < mask_min) || (css_cnt > mask_max))
16420 {
16421 if (css_cnt < mask_min)
16422 {
16423 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
16424 }
16425
16426 if (css_cnt > mask_max)
16427 {
16428 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
16429 }
16430
16431 // skip to next mask
16432
16433 dictpos++;
16434
16435 rd->dictpos = dictpos;
16436
16437 logfile_sub_msg ("STOP");
16438
16439 continue;
16440 }
16441
16442 uint save_css_cnt = css_cnt;
16443
16444 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16445 {
16446 if (opti_type & OPTI_TYPE_APPENDED_SALT)
16447 {
16448 uint salt_len = (uint) data.salts_buf[0].salt_len;
16449 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
16450
16451 uint css_cnt_salt = css_cnt + salt_len;
16452
16453 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
16454
16455 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
16456
16457 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
16458 {
16459 css_buf_salt[j].cs_buf[0] = salt_buf[i];
16460 css_buf_salt[j].cs_len = 1;
16461 }
16462
16463 free (css_buf);
16464
16465 css_buf = css_buf_salt;
16466 css_cnt = css_cnt_salt;
16467 }
16468 }
16469
16470 data.mask = mask;
16471 data.css_cnt = css_cnt;
16472 data.css_buf = css_buf;
16473
16474 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
16475
16476 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16477
16478 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16479
16480 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16481 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16482
16483 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16484
16485 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16486
16487 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16488 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16489
16490 data.root_css_buf = root_css_buf;
16491 data.markov_css_buf = markov_css_buf;
16492
16493 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16494
16495 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16496
16497 local_free (root_table_buf);
16498 local_free (markov_table_buf);
16499
16500 // copy + args
16501
16502 uint css_cnt_l = css_cnt;
16503 uint css_cnt_r;
16504
16505 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16506 {
16507 if (save_css_cnt < 6)
16508 {
16509 css_cnt_r = 1;
16510 }
16511 else if (save_css_cnt == 6)
16512 {
16513 css_cnt_r = 2;
16514 }
16515 else
16516 {
16517 if (opts_type & OPTS_TYPE_PT_UNICODE)
16518 {
16519 if (save_css_cnt == 8 || save_css_cnt == 10)
16520 {
16521 css_cnt_r = 2;
16522 }
16523 else
16524 {
16525 css_cnt_r = 4;
16526 }
16527 }
16528 else
16529 {
16530 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
16531 {
16532 css_cnt_r = 3;
16533 }
16534 else
16535 {
16536 css_cnt_r = 4;
16537 }
16538 }
16539 }
16540 }
16541 else
16542 {
16543 css_cnt_r = 1;
16544
16545 /* unfinished code?
16546 int sum = css_buf[css_cnt_r - 1].cs_len;
16547
16548 for (uint i = 1; i < 4 && i < css_cnt; i++)
16549 {
16550 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
16551
16552 css_cnt_r++;
16553
16554 sum *= css_buf[css_cnt_r - 1].cs_len;
16555 }
16556 */
16557 }
16558
16559 css_cnt_l -= css_cnt_r;
16560
16561 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
16562
16563 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16564 {
16565 hc_device_param_t *device_param = &data.devices_param[device_id];
16566
16567 if (device_param->skipped) continue;
16568
16569 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
16570 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
16571 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
16572
16573 device_param->kernel_params_mp_l_buf64[3] = 0;
16574 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
16575 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
16576 device_param->kernel_params_mp_l_buf32[6] = 0;
16577 device_param->kernel_params_mp_l_buf32[7] = 0;
16578 device_param->kernel_params_mp_l_buf32[8] = 0;
16579
16580 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
16581 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
16582 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
16583 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
16584
16585 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
16586 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
16587 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
16588
16589 device_param->kernel_params_mp_r_buf64[3] = 0;
16590 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
16591 device_param->kernel_params_mp_r_buf32[5] = 0;
16592 device_param->kernel_params_mp_r_buf32[6] = 0;
16593 device_param->kernel_params_mp_r_buf32[7] = 0;
16594
16595 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]);
16596 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]);
16597 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]);
16598
16599 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]);
16600 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]);
16601 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]);
16602
16603 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);
16604 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);
16605 }
16606 }
16607
16608 u64 words_base = data.words_cnt;
16609
16610 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16611 {
16612 if (data.kernel_rules_cnt)
16613 {
16614 words_base /= data.kernel_rules_cnt;
16615 }
16616 }
16617 else if (data.attack_kern == ATTACK_KERN_COMBI)
16618 {
16619 if (data.combs_cnt)
16620 {
16621 words_base /= data.combs_cnt;
16622 }
16623 }
16624 else if (data.attack_kern == ATTACK_KERN_BF)
16625 {
16626 if (data.bfs_cnt)
16627 {
16628 words_base /= data.bfs_cnt;
16629 }
16630 }
16631
16632 data.words_base = words_base;
16633
16634 if (keyspace == 1)
16635 {
16636 log_info ("%llu", (unsigned long long int) words_base);
16637
16638 return (0);
16639 }
16640
16641 if (data.words_cur > data.words_base)
16642 {
16643 log_error ("ERROR: restore value greater keyspace");
16644
16645 return (-1);
16646 }
16647
16648 if (data.words_cur)
16649 {
16650 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16651 {
16652 for (uint i = 0; i < data.salts_cnt; i++)
16653 {
16654 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16655 }
16656 }
16657 else if (data.attack_kern == ATTACK_KERN_COMBI)
16658 {
16659 for (uint i = 0; i < data.salts_cnt; i++)
16660 {
16661 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16662 }
16663 }
16664 else if (data.attack_kern == ATTACK_KERN_BF)
16665 {
16666 for (uint i = 0; i < data.salts_cnt; i++)
16667 {
16668 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16669 }
16670 }
16671 }
16672
16673 /*
16674 * Inform user about possible slow speeds
16675 */
16676
16677 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16678 {
16679 if (data.words_base < kernel_power_all)
16680 {
16681 if (quiet == 0)
16682 {
16683 log_info ("ATTENTION!");
16684 log_info (" The wordlist or mask you are using is too small.");
16685 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
16686 log_info (" The cracking speed will drop.");
16687 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16688 log_info ("");
16689 }
16690 }
16691 }
16692
16693 /*
16694 * Update loopback file
16695 */
16696
16697 if (loopback == 1)
16698 {
16699 time_t now;
16700
16701 time (&now);
16702
16703 uint random_num = get_random_num (0, 9999);
16704
16705 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16706
16707 data.loopback_file = loopback_file;
16708 }
16709
16710 /*
16711 * Update dictionary statistic
16712 */
16713
16714 if (keyspace == 0)
16715 {
16716 dictstat_fp = fopen (dictstat, "wb");
16717
16718 if (dictstat_fp)
16719 {
16720 lock_file (dictstat_fp);
16721
16722 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16723
16724 fclose (dictstat_fp);
16725 }
16726 }
16727
16728 data.devices_status = STATUS_RUNNING;
16729
16730 if (initial_restore_done == 0)
16731 {
16732 if (data.restore_disable == 0) cycle_restore ();
16733
16734 initial_restore_done = 1;
16735 }
16736
16737 hc_timer_set (&data.timer_running);
16738
16739 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16740 {
16741 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16742 {
16743 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16744 if (quiet == 0) fflush (stdout);
16745 }
16746 }
16747 else if (wordlist_mode == WL_MODE_STDIN)
16748 {
16749 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16750 if (data.quiet == 0) log_info ("");
16751 }
16752
16753 time_t runtime_start;
16754
16755 time (&runtime_start);
16756
16757 data.runtime_start = runtime_start;
16758
16759 /**
16760 * create cracker threads
16761 */
16762
16763 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
16764
16765 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16766 {
16767 hc_device_param_t *device_param = &devices_param[device_id];
16768
16769 if (wordlist_mode == WL_MODE_STDIN)
16770 {
16771 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16772 }
16773 else
16774 {
16775 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16776 }
16777 }
16778
16779 // wait for crack threads to exit
16780
16781 hc_thread_wait (data.devices_cnt, c_threads);
16782
16783 local_free (c_threads);
16784
16785 data.restore = 0;
16786
16787 // finalize task
16788
16789 logfile_sub_var_uint ("status-after-work", data.devices_status);
16790
16791 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16792
16793 if (data.devices_status == STATUS_CRACKED) break;
16794 if (data.devices_status == STATUS_ABORTED) break;
16795
16796 if (data.devices_status == STATUS_BYPASS)
16797 {
16798 data.devices_status = STATUS_RUNNING;
16799 }
16800
16801 if (induction_dictionaries_cnt)
16802 {
16803 unlink (induction_dictionaries[0]);
16804 }
16805
16806 free (induction_dictionaries);
16807
16808 if (attack_mode != ATTACK_MODE_BF)
16809 {
16810 induction_dictionaries = scan_directory (induction_directory);
16811
16812 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16813 }
16814
16815 if (benchmark == 0)
16816 {
16817 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16818 {
16819 if (quiet == 0) clear_prompt ();
16820
16821 if (quiet == 0) log_info ("");
16822
16823 if (status == 1)
16824 {
16825 status_display ();
16826 }
16827 else
16828 {
16829 if (quiet == 0) status_display ();
16830 }
16831
16832 if (quiet == 0) log_info ("");
16833 }
16834 }
16835
16836 if (attack_mode == ATTACK_MODE_BF)
16837 {
16838 dictpos++;
16839
16840 rd->dictpos = dictpos;
16841 }
16842 else
16843 {
16844 if (induction_dictionaries_cnt)
16845 {
16846 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16847 }
16848 else
16849 {
16850 dictpos++;
16851
16852 rd->dictpos = dictpos;
16853 }
16854 }
16855
16856 time_t runtime_stop;
16857
16858 time (&runtime_stop);
16859
16860 data.runtime_stop = runtime_stop;
16861
16862 logfile_sub_uint (runtime_start);
16863 logfile_sub_uint (runtime_stop);
16864
16865 logfile_sub_msg ("STOP");
16866
16867 global_free (subid);
16868 }
16869
16870 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16871
16872 if (data.devices_status == STATUS_CRACKED) break;
16873 if (data.devices_status == STATUS_ABORTED) break;
16874 if (data.devices_status == STATUS_QUIT) break;
16875
16876 if (data.devices_status == STATUS_BYPASS)
16877 {
16878 data.devices_status = STATUS_RUNNING;
16879 }
16880 }
16881
16882 // 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
16883
16884 if (attack_mode == ATTACK_MODE_STRAIGHT)
16885 {
16886 if (data.wordlist_mode == WL_MODE_FILE)
16887 {
16888 if (data.dictfile == NULL)
16889 {
16890 if (dictfiles != NULL)
16891 {
16892 data.dictfile = dictfiles[0];
16893
16894 hc_timer_set (&data.timer_running);
16895 }
16896 }
16897 }
16898 }
16899 // NOTE: combi is okay because it is already set beforehand
16900 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16901 {
16902 if (data.dictfile == NULL)
16903 {
16904 if (dictfiles != NULL)
16905 {
16906 hc_timer_set (&data.timer_running);
16907
16908 data.dictfile = dictfiles[0];
16909 }
16910 }
16911 }
16912 else if (attack_mode == ATTACK_MODE_BF)
16913 {
16914 if (data.mask == NULL)
16915 {
16916 hc_timer_set (&data.timer_running);
16917
16918 data.mask = masks[0];
16919 }
16920 }
16921
16922 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16923 {
16924 data.devices_status = STATUS_EXHAUSTED;
16925 }
16926
16927 // if cracked / aborted remove last induction dictionary
16928
16929 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16930 {
16931 struct stat induct_stat;
16932
16933 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16934 {
16935 unlink (induction_dictionaries[file_pos]);
16936 }
16937 }
16938
16939 // wait for non-interactive threads
16940
16941 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16942 {
16943 hc_thread_wait (1, &ni_threads[thread_idx]);
16944 }
16945
16946 local_free (ni_threads);
16947
16948 // wait for interactive threads
16949
16950 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16951 {
16952 hc_thread_wait (1, &i_thread);
16953 }
16954
16955 // we dont need restore file anymore
16956 if (data.restore_disable == 0)
16957 {
16958 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16959 {
16960 unlink (eff_restore_file);
16961 unlink (new_restore_file);
16962 }
16963 else
16964 {
16965 cycle_restore ();
16966 }
16967 }
16968
16969 // finally save left hashes
16970
16971 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16972 {
16973 save_hash ();
16974 }
16975
16976 /**
16977 * Clean up
16978 */
16979
16980 if (benchmark == 1)
16981 {
16982 status_benchmark ();
16983
16984 log_info ("");
16985 }
16986 else
16987 {
16988 if (quiet == 0) clear_prompt ();
16989
16990 if (quiet == 0) log_info ("");
16991
16992 if (status == 1)
16993 {
16994 status_display ();
16995 }
16996 else
16997 {
16998 if (quiet == 0) status_display ();
16999 }
17000
17001 if (quiet == 0) log_info ("");
17002 }
17003
17004 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17005 {
17006 hc_device_param_t *device_param = &data.devices_param[device_id];
17007
17008 if (device_param->skipped) continue;
17009
17010 local_free (device_param->result);
17011
17012 local_free (device_param->combs_buf);
17013
17014 local_free (device_param->hooks_buf);
17015
17016 local_free (device_param->device_name);
17017
17018 local_free (device_param->device_name_chksum);
17019
17020 local_free (device_param->device_version);
17021
17022 local_free (device_param->driver_version);
17023
17024 if (device_param->pws_buf) myfree (device_param->pws_buf);
17025 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
17026 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
17027 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
17028 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
17029 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
17030 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
17031 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
17032 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
17033 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
17034 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
17035 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
17036 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
17037 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
17038 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
17039 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
17040 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
17041 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
17042 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
17043 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
17044 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
17045 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
17046 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
17047 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
17048 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
17049 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
17050 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
17051 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
17052 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
17053
17054 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
17055 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
17056 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
17057 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
17058 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
17059 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
17060 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
17061 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
17062 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
17063 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
17064
17065 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
17066 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
17067 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
17068
17069 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
17070 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
17071 }
17072
17073 // reset default fan speed
17074
17075 #ifdef HAVE_HWMON
17076 if (gpu_temp_disable == 0)
17077 {
17078 #ifdef HAVE_ADL
17079 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
17080 {
17081 hc_thread_mutex_lock (mux_adl);
17082
17083 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17084 {
17085 hc_device_param_t *device_param = &data.devices_param[device_id];
17086
17087 if (device_param->skipped) continue;
17088
17089 if (data.hm_device[device_id].fan_supported == 1)
17090 {
17091 int fanspeed = temp_retain_fanspeed_value[device_id];
17092
17093 if (fanspeed == -1) continue;
17094
17095 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
17096
17097 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
17098 }
17099 }
17100
17101 hc_thread_mutex_unlock (mux_adl);
17102 }
17103 #endif // HAVE_ADL
17104 }
17105
17106 #ifdef HAVE_ADL
17107 // reset power tuning
17108
17109 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
17110 {
17111 hc_thread_mutex_lock (mux_adl);
17112
17113 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17114 {
17115 hc_device_param_t *device_param = &data.devices_param[device_id];
17116
17117 if (device_param->skipped) continue;
17118
17119 if (data.hm_device[device_id].od_version == 6)
17120 {
17121 // check powertune capabilities first, if not available then skip device
17122
17123 int powertune_supported = 0;
17124
17125 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
17126 {
17127 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
17128
17129 return (-1);
17130 }
17131
17132 if (powertune_supported != 0)
17133 {
17134 // powercontrol settings
17135
17136 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)
17137 {
17138 log_info ("ERROR: Failed to restore the ADL PowerControl values");
17139
17140 return (-1);
17141 }
17142
17143 // clocks
17144
17145 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
17146
17147 performance_state->iNumberOfPerformanceLevels = 2;
17148
17149 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
17150 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
17151 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
17152 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
17153
17154 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)
17155 {
17156 log_info ("ERROR: Failed to restore ADL performance state");
17157
17158 return (-1);
17159 }
17160
17161 local_free (performance_state);
17162 }
17163 }
17164 }
17165
17166 hc_thread_mutex_unlock (mux_adl);
17167 }
17168 #endif // HAVE_ADL
17169
17170 if (gpu_temp_disable == 0)
17171 {
17172 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
17173 if (data.hm_nv)
17174 {
17175 #if defined(LINUX) && defined(HAVE_NVML)
17176
17177 hm_NVML_nvmlShutdown (data.hm_nv);
17178
17179 nvml_close (data.hm_nv);
17180
17181 #elif defined(WIN) && (HAVE_NVAPI)
17182
17183 hm_NvAPI_Unload (data.hm_nv);
17184
17185 nvapi_close (data.hm_nv);
17186
17187 #endif
17188
17189 data.hm_nv = NULL;
17190 }
17191 #endif
17192
17193 #ifdef HAVE_ADL
17194 if (data.hm_amd)
17195 {
17196 hm_ADL_Main_Control_Destroy (data.hm_amd);
17197
17198 adl_close (data.hm_amd);
17199 data.hm_amd = NULL;
17200 }
17201 #endif
17202 }
17203 #endif // HAVE_HWMON
17204
17205 // free memory
17206
17207 local_free (masks);
17208
17209 local_free (dictstat_base);
17210
17211 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
17212 {
17213 pot_t *pot_ptr = &pot[pot_pos];
17214
17215 hash_t *hash = &pot_ptr->hash;
17216
17217 local_free (hash->digest);
17218
17219 if (isSalted)
17220 {
17221 local_free (hash->salt);
17222 }
17223 }
17224
17225 local_free (pot);
17226
17227 local_free (all_kernel_rules_cnt);
17228 local_free (all_kernel_rules_buf);
17229
17230 local_free (wl_data->buf);
17231 local_free (wl_data);
17232
17233 local_free (bitmap_s1_a);
17234 local_free (bitmap_s1_b);
17235 local_free (bitmap_s1_c);
17236 local_free (bitmap_s1_d);
17237 local_free (bitmap_s2_a);
17238 local_free (bitmap_s2_b);
17239 local_free (bitmap_s2_c);
17240 local_free (bitmap_s2_d);
17241
17242 #ifdef HAVE_HWMON
17243 local_free (temp_retain_fanspeed_value);
17244 #ifdef HAVE_ADL
17245 local_free (od_clock_mem_status);
17246 local_free (od_power_control_status);
17247 #endif // ADL
17248 #endif
17249
17250 global_free (devices_param);
17251
17252 global_free (kernel_rules_buf);
17253
17254 global_free (root_css_buf);
17255 global_free (markov_css_buf);
17256
17257 global_free (digests_buf);
17258 global_free (digests_shown);
17259 global_free (digests_shown_tmp);
17260
17261 global_free (salts_buf);
17262 global_free (salts_shown);
17263
17264 global_free (esalts_buf);
17265
17266 global_free (words_progress_done);
17267 global_free (words_progress_rejected);
17268 global_free (words_progress_restored);
17269
17270 if (pot_fp) fclose (pot_fp);
17271
17272 if (data.devices_status == STATUS_QUIT) break;
17273 }
17274
17275 // destroy others mutex
17276
17277 hc_thread_mutex_delete (mux_dispatcher);
17278 hc_thread_mutex_delete (mux_counter);
17279 hc_thread_mutex_delete (mux_display);
17280 hc_thread_mutex_delete (mux_adl);
17281
17282 // free memory
17283
17284 local_free (eff_restore_file);
17285 local_free (new_restore_file);
17286
17287 local_free (rd);
17288
17289 // tuning db
17290
17291 tuning_db_destroy (tuning_db);
17292
17293 // loopback
17294
17295 local_free (loopback_file);
17296
17297 if (loopback == 1) unlink (loopback_file);
17298
17299 // induction directory
17300
17301 if (induction_dir == NULL)
17302 {
17303 if (attack_mode != ATTACK_MODE_BF)
17304 {
17305 if (rmdir (induction_directory) == -1)
17306 {
17307 if (errno == ENOENT)
17308 {
17309 // good, we can ignore
17310 }
17311 else if (errno == ENOTEMPTY)
17312 {
17313 // good, we can ignore
17314 }
17315 else
17316 {
17317 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
17318
17319 return (-1);
17320 }
17321 }
17322
17323 local_free (induction_directory);
17324 }
17325 }
17326
17327 // outfile-check directory
17328
17329 if (outfile_check_dir == NULL)
17330 {
17331 if (rmdir (outfile_check_directory) == -1)
17332 {
17333 if (errno == ENOENT)
17334 {
17335 // good, we can ignore
17336 }
17337 else if (errno == ENOTEMPTY)
17338 {
17339 // good, we can ignore
17340 }
17341 else
17342 {
17343 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
17344
17345 return (-1);
17346 }
17347 }
17348
17349 local_free (outfile_check_directory);
17350 }
17351
17352 time_t proc_stop;
17353
17354 time (&proc_stop);
17355
17356 logfile_top_uint (proc_start);
17357 logfile_top_uint (proc_stop);
17358
17359 logfile_top_msg ("STOP");
17360
17361 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
17362 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
17363
17364 if (data.ocl) ocl_close (data.ocl);
17365
17366 if (data.devices_status == STATUS_ABORTED) return 2;
17367 if (data.devices_status == STATUS_QUIT) return 2;
17368 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
17369 if (data.devices_status == STATUS_EXHAUSTED) return 1;
17370 if (data.devices_status == STATUS_CRACKED) return 0;
17371
17372 return -1;
17373 }
Hashcat additions to support pwdhash